Abstract
We present the second generation of the tool Seminator that transforms transitionbased generalized Büchi automata (TGBAs) into equivalent semideterministic automata. The tool has been extended with numerous optimizations and produces considerably smaller automata than its first version. In connection with the stateoftheart LTL to TGBAs translator Spot, Seminator 2 produces smaller (on average) semideterministic automata than the direct LTL to semideterministic automata translator ltl2ldgba of the Owl library. Further, Seminator 2 has been extended with an improved NCSB complementation procedure for semideterministic automata, providing a new way to complement automata that is competitive with stateoftheart complementation tools.
Download conference paper PDF
1 Introduction
Semideterministic [24] automata are automata where each accepting run makes only finitely many nondeterministic choices. The merit of this interstage between deterministic and nondeterministic automata comes from two facts known since the late 1980s. First, every nondeterministic Büchi automaton with n states can be transformed into an equivalent semideterministic Büchi automaton with at most \(4^n\) states [7, 24]. Note that asymptotically optimal determinization procedures transform nondeterministic Büchi automata to deterministic automata with \(2^{\mathcal {O}(n\log n)}\) states [24] and with a more complex (typically Rabin) acceptance condition, as deterministic Büchi automata are strictly less expressive. Second, some algorithms cannot handle nondeterministic automata, but they can handle semideterministic ones; for example, algorithms for qualitative model checking of Markov decision processes (MDPs) [7, 29].
For theoreticians, the difference between the complexity of determinization and semideterminization is not dramatic—both constructions are exponential. However, the difference is important for authors and users of practical automatabased tools—automata size and the complexity of their acceptance condition often have a significant impact on tool performance. This latter perspective has recently initiated another wave of research on semideterministic automata. Since 2015, many new results have been published: several direct translations of LTL to semideterministic automata [11, 15, 16, 26], specialized complementation constructions for semideterministic automata [4, 6], algorithms for quantitative model checking of MDPs based on semideterministic automata [13, 25], a transformation of semideterministic automata to deterministic parity automata [10], and reinforcement learning of control policy using semideterministic automata [21].
In 2017, we introduced Seminator 1.1 [5], a tool that transforms nondeterministic automata to semideterministic ones. The original semideterminization procedure of Courcoubetis and Yannakakis [7] works with standard Büchi automata (BAs). Seminator 1.1 extends this construction to handle more compact automata, namely transitionbased Büchi automata (TBAs) and transitionbased generalized Büchi automata (TGBAs). TBAs use accepting transitions instead of accepting states, and TGBAs have several sets of accepting transitions, each of these sets must be visited infinitely often by accepting runs. The main novelty of Seminator 1.1 was that it performed degeneralization and semideterminization of a TGBA simultaneously. As a result, it could translate TGBAs to smaller semideterministic automata than (to our best knowledge) the only other tool for automata semideterminization called nba2ldba [26]. This tool only accepts BAs as input, and thus TGBAs must be degeneralized before nba2ldba is called.
Moreover, in connection with the LTL to TGBAs translator ltl2tgba of Spot [8], Seminator 1.1 provided a translation of LTL to semideterministic automata that can compete with the direct LTL to semideterministic TGBAs translator ltl2ldba [26]. More precisely, our experiments [5] showed that the combination of ltl2tgba and Seminator 1.1 outperforms ltl2ldba on LTL formulas that ltl2tgba translates directly to deterministic or semideterministic TGBA (i.e., when Seminator has no work to do), while ltl2ldba produced (on average) smaller semideterministic TGBAs on the remaining LTL formulas (i.e., when the TGBA produced by ltl2tgba has to be semideterminized by Seminator).
This paper presents Seminator 2, which changes the situation. With many improvements in semideterminization, the combination of ltl2tgba and Seminator 2 now translates LTL to smaller (on average) semideterministic TGBAs than ltl2ldba even for the cases when ltl2tgba produces a TGBA that is not semideterministic. Moreover, this holds even when we compare to ltl2ldgba, which is the current successor of ltl2ldba distributed with Owl [19].
Further, Seminator 2 now provides a new feature: complementation of TGBAs. Seminator 2 chains semideterminization with the complementation algorithm called NCSB [4, 6], which is tailored for semideterministic BAs. Our experiments show that the complementation in Seminator 2 is fully competitive with complementations implemented in stateoftheart tools [1, 8, 20, 23, 30].
2 Improvements in Semideterminization
First of all, we recall the definition of semideterministic automata and principles of the semideterminization procedure implemented in Seminator 1.1 [5].
Let \(\mathcal {A}=(Q,\varSigma ,\delta ,q_0,\{F_1,\ldots ,F_n\})\) be a TGBA over alphabet \(\varSigma \), with a finite set of states Q, a transition relation \(\delta \subseteq Q\times \varSigma \times Q\), an initial state \(q_0\in Q\), and sets of accepting transitions \(F_1,\ldots ,F_n\subseteq \delta \). Then \(\mathcal {A}\) is semideterministic if there exists a subset \(Q_D\subseteq Q\) such that (i) each transition from \(Q_D\) goes back to \(Q_D\) (i.e., \(\delta \cap (Q_D\times \varSigma \times (Q\smallsetminus Q_D))=\emptyset \)), (ii) all states of \(Q_D\) are deterministic (i.e., for each \(q\in Q_D\) and \(a\in \varSigma \) there is at most one \(q'\) such that \((q,a,q')\in \delta \)), and (iii) each accepting transition starts in a state of \(Q_D\) (i.e., \(F_1,\ldots ,F_n\subseteq Q_D\times \varSigma \times Q_D\)).
The part of \(\mathcal {A}\) delimited by states of \(Q_D\) is called deterministic, while the part formed by the remaining states \(Q\smallsetminus Q_D\) is called nondeterministic, although it could contain deterministic states too. The transitions leading from the nondeterministic part to the deterministic one are called cuttransitions. The structure of a semideterministic automaton is depicted in Fig. 1.
Intuitively, a TGBA \(\mathcal {A}\) with a set of states Q and a single set of accepting transitions F can be transformed into a semideterministic TBA \(\mathcal {B}\) as follows. First, we use a copy of \(\mathcal {A}\) as the nondeterministic part of \(\mathcal {B}\). The deterministic part of \(\mathcal {B}\) has states of the form (M, N) such that \(Q\supseteq M\supseteq N\) and \(M\ne \emptyset \). Every accepting transition \((q,a,q')\in F\) induces a cuttransition \((q,a,(\{q'\},\emptyset ))\) of \(\mathcal {B}\). The deterministic part is then constructed to track all runs of \(\mathcal {A}\) from each such state \(q'\) using the powerset construction. More precisely, the first element of (M, N) tracks all runs while the second element tracks only the runs that passed some accepting transition of F. Each transition of the deterministic part, that would reach a state where \(M=N\) (socalled breakpoint) is replaced with an accepting transition of \(\mathcal {B}\) leading to state \((M,N')\), where \(N'\) tracks only the runs of \(\mathcal {A}\) passing an accepting transition of F in the current step.
Seminator 1.1 extended this procedure to construct a semideterministic TBA even for a TGBA with multiple acceptance sets \(F_1,\ldots ,F_n\). States of the deterministic part are now triples (M, N, i), where \(i\in \{0,\ldots ,n1\}\) is called level and it has a similar semantics as in degeneralization. Cuttransitions are induced by transitions of \(F_n\) and they lead to states of the form \((\{q'\},\emptyset ,0)\). The level i says that N tracks runs that passed a transition of \(F_{i+1}\) since the last level change. When the deterministic part reaches a state (M, N, i) with \(M=N\), we change the level to \(i'=(i+1)\bmod n\) and modify N to track only runs passing \(F_{i'+1}\) in the current step. Transitions changing the level are accepting.
A precise description of these semideterminization procedures and proofs of their correctness can be found in Blahoudek’s dissertation [3]. Now we briefly explain the most important optimizations added in Seminator 2 (we work on a journal paper with their formal description). Each optimization can be enabled/disabled by the corresponding option. All of them are enabled by default.

sccaware approach identifies, for each cuttransition, the strongly connected component (SCC) of \(\mathcal {A}\) that contains the target of the transition triggering the cuttransition. The sets M, N then track only runs staying in this SCC.

reusedeterministic treats in a specific way each deterministic SCC from which only deterministic SCCs are reachable in \(\mathcal {A}\): it (i) does not include them in the nondeterministic part, and (ii) copies them (and their successors) in the deterministic part as they are, including the original acceptance transitions. This optimization can result in a semideterministic TGBA with multiple acceptance sets on output.

cutalways changes the policy when cuttransitions are created: they are now triggered by all transitions of \(\mathcal {A}\) with the target state in an accepting SCC.

powersetoncut applies the powerset construction when computing targets of cuttransitions. The target of a cuttransition leading from q is constructed in the same way as the successor of the hypothetical state \((\{q\},\emptyset ,0)\) of the deterministic part.

skiplevels is a variant of the level jumping trick from TGBA degeneralization [2]. Roughly speaking, a single transition in the deterministic part can change the level i directly to \(i+j\) where \(j\ge 1\) if all runs passed acceptance transitions from all the sets \(F_{i+1},\ldots ,F_{i+j}\) in the current step.

jumptobottommost makes sure that all cuttransitions leading to states with the same M component lead to the same state (M, N, i) for some N and i. It relies on the fact that each run takes only one cuttransition, and thus only the component M of the cuttransition’s target state is important for determining the acceptance of the run. During the original construction, many states of the form \((M,N',i')\) may appear in different SCCs. After the construction finishes, this optimization redirects each cuttransition leading to \((M,N',i')\) to some state of the form (M, N, i) that belongs to the bottommost SCC (in a topological ordering of the SCCs) that contains such a state. This is inspired by a similar trick used by Křetínský et al. [18] in a different context.

powersetforweak simplifies the construction for weak accepting SCCs (i.e., SCCs where all cycles are accepting) of \(\mathcal {A}\). For such SCCs it just applies the powerset construction (builds states of the form M instead of triples (M, N, i)) with all transitions accepting in the deterministic part.
Note that Seminator 1.1 can produce a semideterministic TGBA with multiple acceptance sets only when it gets a semideterministic TGBA as input. Seminator 2 produces such automata more often due to reusedeterministic.
3 Implementation and Usage
Seminator 2 is an almost complete rewrite of Seminator [5], and is still distributed under the GNU GPL 3.0 license. Its distribution tarball and source code history are hosted on GitHub (https://github.com/mklokocka/seminator). The package contains sources of the tool with two userinterfaces (a commandline tool and Python bindings), a testsuite, and some documentation.
Seminator is implemented in C++ on top of the datastructures provided by the Spot library [8], and reuses its input/output functions, simplification algorithms, and the NCSB complementation. The main implementation effort lies in the optimized semideterminization and an alternative version of NCSB.
The first user interface is a commandline tool called seminator. Its highlevel workflow is pictured in Fig. 2. By default (toppart of Fig. 2) it takes a TGBA (or TBA or BA) on input and produces a semideterministic TGBA (or TBA or BA if requested). Figure 2 details various switches that control the optional simplifications and acceptance transformations that occur before the semideterminization itself. The pre and postprocessing are provided by the Spot library. The semideterminization algorithm can be adjusted by additional commandline options (not shown in Fig. 2) that enable or disable optimizations of Sect. 2. As Spot simplification routines are stronger on automata with simpler acceptance conditions, it sometimes pays off to convert the automaton to TBA or BA first. If the input is a TGBA, seminator attempts three semideterminizations, one on the input TGBA, one on its TBA equivalent, and one on its BA equivalent; only the smallest result is retained. If the input is already a TBA (resp. a BA), only the last two (resp. one) routes are attempted.
The complement option activates the bottom part of Fig. 2 with two variants of the NCSB complementation [4]: "spot" stands for a transitionbased adaptation of the original algorithm (implemented in Spot); "pldi" refers to its modification based on the optimization by Chen et al. [6, Section 5.3] (implemented in Seminator 2). Both variants take a TBA as input and produce a TBA. The options tba and –ba apply on the final complement automaton only.
The seminator tool can now process automata in batch, making it possible to build pipelines with other commands. For instance the pipeline
uses Spot’s ltl2tgba command to read a list of LTL formulas from input.ltl and transform it into a stream of TGBAs that is passed to seminator, which transforms them into semideterministic TGBAs, and finally Spot’s autfilt saves into output.hoa the automata with 3 states or more.
Python bindings form the second userinterface and are installed by the Seminator package as an extension of Spot’s own Python bindings. It offers several functions, all working with Spot’s automata (twa_graph objects):

semi_determinize() implements the semideterminization procedure;

complement_semidet() implements the "pldi" variant of the NCSB complementation for semideterministic automata (the other variant is available under the same function name in the bindings of Spot);

highlight_components() and highlight_cut() provide ways to highlight the nondeterministic and the deterministic parts of a semideterministic automaton, and its cuttransitions;

seminator() provides an interface similar to the commandline seminator tool with options that selectively enable or disable optimizations or trigger complementation.
The Python bindings integrate well with the interactive notebooks of Jupyter [17]. Figure 3 shows an example of such a notebook, using the seminator() and highlight_components() functions. Additional Jupyter notebooks, distributed with the tool, document the effect of the various optimization options.^{Footnote 1}
4 Experimental Evaluation
We evaluate the performance of Seminator 2 for both semideterminization and complementation of TGBAs. We compare our tool against several tools listed in Table 1. As ltl2ldgba needs LTL on input, we used the set of 221 LTL formulas already considered for benchmarking in the literature [9, 12, 14, 22, 27]. To provide TGBAs as input for Seminator 2, we use Spot’s ltl2tgba to convert the LTL formulas. Based on the automata produced by ltl2tgba, we distinguish three categories of formulas: deterministic (152 formulas), semideterministic but not deterministic (49 formulas), and not semideterministic (20 formulas). This division is motivated by the fact that Seminator 2 applies its semideterminization only on automata that are not semideterministic, and that some complementation tools use different approaches to deterministic automata. We have also generated 500 random LTL formulas of each category.
The scripts and formulas used in those experiments can be found online,^{Footnote 2} as well as a Docker image with these scripts and all the tools installed.^{Footnote 3} All experiments were run inside the supplied Docker image on a laptop Dell XPS13 with Intel i71065G7, 16 GB RAM, and running Linux.
4.1 Semideterminization
We compare Seminator 2 to its older version 1.1 and to ltl2ldgba of Owl. We do not include Buchifier [16] as it is available only as a binary for Windows. Also, we did not include nba2ldba [26] due to the lack of space and the fact that even Seminator 1.1 performs significantly better than nba2ldba [5].
Recall that Seminator 2 calls Spot’s automata simplification routines on constructed automata. To get a fair comparison, we apply these routines also to the results of other tools, indicated by +Spot in the results. Further, ltl2ldgba of Owl can operate in two modes: symmetric and asymmetric. For each formula, we run both settings and pick the better result, indicated by +best.
Table 2 presents the cumulative results for each semideterminization tool and each benchmark set (we actually merged deterministic and semideterministic benchmark sets). The timeout of 30 s was reached by Owl for one formula in the (semi)deterministic category and by Seminator 1.1 for one formula in the not semideterministic category. Besides timeouts, the running times of all tools were always below 3 s, with a few exceptions for Seminator 1.1.
In the (semi)deterministic category, the automaton produced by ltl2tgba and passed to both versions of Seminator is already semideterministic. Hence, both versions of Seminator have nothing to do. This category, in fact, compares ltl2tgba of Spot against ltl2ldgba of Owl.
Figure 4 shows the distribution of differences between semideterministic automata produced by Owl+best+Spot and Seminator 2 for the not semideterministic random set. A dot at coordinates (x, y) represents a formula for which Owl and Seminator 2 produced automata with x and y states, respectively.
We can observe a huge improvement brought by Seminator 2 in not semideterministic benchmarks: while in 2017 Seminator 1.1 produced a smaller automaton than Owl in only few cases in this category [5], Seminator 2 is now more than competitive despite the fact that also Owl was improved over the time.
4.2 Complementation
We compare Seminator 2 with the complementation of ROLL based on automata learning (formerly presented as Buechic), the determinizationbased algorithm [23] implemented in GOAL, the asymptotically optimal Fribourg complementation implemented as a plugin for GOAL, and with Spot (autfilt complement). We apply the simplifications from Spot to all results and we use Spot’s ltl2tgba to create the input Büchi automata for all tools, using transitionbased generalized acceptance or statebased acceptance as appropriate (only Seminator 2 and Spot can complement transitionbased generalized Büchi automata). The timeout of 120 s was reached once by both Seminator 2 and Spot, 6 times by Fribourg, and 13 times by GOAL and ROLL.
Table 3 shows results for complementation in the same way as Table 2 does for semideterminization. For the deterministic benchmark, we can see quite similar results from all tools but ROLL. This is caused by the fact that complementation of deterministic automata is easy. Some tools (including Spot) even apply a dedicated complementation procedure. It comes at no surprise that the specialized algorithm of Seminator 2 performs better than most other complementations in the semideterministic category. Interestingly, this carries over to the not semideterministic category. The results demonstrate that the 2step approach of Seminator 2 to complementation performs well in practice. Figure 5 offers more detailed insight into distribution of automata sizes created by Seminator 2, Spot, and Fribourg+Spot for random benchmarks in this category.
Finally, Fig. 6 compares the running times of these tools over the 83 hard cases of not semideterministic random benchmark (a case is hard if at least one tool did not finish in 10 s). We can see that Seminator 2 and Spot run significantly faster than the other tools.
5 Conclusion
We have presented Seminator 2, which is a substantially improved version of Seminator 1.1. The tool now offers a competitive complementation of TGBA. Furthermore, the semideterminization code was rewritten and offers new optimizations that significantly reduce the size of produced automata. Finally, new userinterfaces enable convenient processing of large automata sets thanks to the support of pipelines and batch processing, and versatile applicability in education and research thanks to the integration with Spot’s Python bindings.
References
Allred, J.D., UltesNitsche, U.: A simple and optimal complementation algorithm for Büchi automata. In: LICS 2018, pp. 46–55. ACM (2018)
Babiak, T., Badie, T., DuretLutz, A., Křetínský, M., Strejček, J.: Compositional approach to suspension and other improvements to LTL translation. In: Bartocci, E., Ramakrishnan, C.R. (eds.) SPIN 2013. LNCS, vol. 7976, pp. 81–98. Springer, Heidelberg (2013). https://doi.org/10.1007/9783642391767_6
Blahoudek, F.: Automata for formal methods: little steps towards perfection. PhD thesis, Masaryk University, Brno, Czech Republic (2018)
Blahoudek, F., Heizmann, M., Schewe, S., Strejček, J., Tsai, M.H.: Complementing semideterministic Büchi automata. In: Chechik, M., Raskin, J.F. (eds.) TACAS 2016. LNCS, vol. 9636, pp. 770–787. Springer, Heidelberg (2016). https://doi.org/10.1007/9783662496749_49
Blahoudek, F., DuretLutz, A., Klokočka, M., Křetínský, M., Streček, J.: Seminator: a tool for semideterminization of omegaautomata. In: LPAR 2017, vol. 46 of EPiC Series in Computing, pp. 356–367. EasyChair (2017). https://easychair.org/publications/paper/340360
Chen, Y.F., Heizmann, M., Lengál, O., Li, Y., Tsai, M.H., Turrini, A., Zhang, L.: Advanced automatabased algorithms for program termination checking. In: PLDI 2018, pp. 135–150 (2018)
Courcoubetis, C., Yannakakis, M.: Verifying temporal properties of finitestate probabilistic programs. In: FOCS 1988, pp. 338–345. IEEE Computer Society (1988)
DuretLutz, A., Lewkowicz, A., Fauchille, A., Michaud, T., Renault, É., Xu, L.: Spot 2.0 — a framework for LTL and \(\omega \)automata manipulation. In: Artho, C., Legay, A., Peled, D. (eds.) ATVA 2016. LNCS, vol. 9938, pp. 122–129. Springer, Cham (2016). https://doi.org/10.1007/9783319465203_8
Dwyer, M.B., Avrunin, G.S., Corbett, J.C.: Property specification patterns for finitestate verification. In: FMSP 1998, pp. 7–15. ACM (1998)
Esparza, J., Křetínský, J., Raskin, J.F., Sickert, S.: From LTL and limitdeterministic Büchi automata to deterministic parity automata. In: Legay, A., Margaria, T. (eds.) TACAS 2017. LNCS, vol. 10205, pp. 426–442. Springer, Heidelberg (2017). https://doi.org/10.1007/9783662545775_25
Esparza, J., Křetínský, J., Sickert, S.: One theorem to rule them all: a unified translation of LTL into \(\omega \)automata. In: LICS 2018, pp. 384–393. ACM (2018)
Etessami, K., Holzmann, G.J.: Optimizing Büchi automata. In: Palamidessi, C. (ed.) CONCUR 2000. LNCS, vol. 1877, pp. 153–168. Springer, Heidelberg (2000). https://doi.org/10.1007/3540446184_13
Hahn, E.M., Li, G., Schewe, S., Turrini, A., Zhang, L.: Lazy probabilistic model checking without determinisation. In: CONCUR 2015, vol. 42 of LIPIcs, pp. 354–367. Schloss Dagstuhl  LeibnizZentrum für Informatik (2015)
Holeček, J., Kratochvíla, T., Řehák, V., Šafránek, D., Šimeček, P.: Verification results in Liberouter project. Technical Report 03, p. 32 CESNET, 9 (2004)
Kini, D., Viswanathan, M.: Limit Deterministic and Probabilistic Automata for LTL\(\setminus \) GU. In: Baier, Christel, Tinelli, Cesare (eds.) TACAS 2015. LNCS, vol. 9035, pp. 628–642. Springer, Heidelberg (2015). https://doi.org/10.1007/9783662466810_57
Kini, D., Viswanathan, M.: Optimal translation of LTL to limit deterministic automata. In: Legay, A., Margaria, T. (eds.) TACAS 2017. LNCS, vol. 10206, pp. 113–129. Springer, Heidelberg (2017). https://doi.org/10.1007/9783662545805_7
Kluyver, T., et al.: Jupyter notebooks – a publishing format for reproducible computational workflows. In: ELPUB 2016, pp. 87–90. IOS Press (2016)
Křetínský, J., Meggendorfer, T., Waldmann, C., Weininger, M.: Index appearance record for transforming rabin automata into parity automata. In: Legay, A., Margaria, T. (eds.) TACAS 2017. LNCS, vol. 10205, pp. 443–460. Springer, Heidelberg (2017). https://doi.org/10.1007/9783662545775_26
Křetínský, J., Meggendorfer, T., Sickert, S.: Owl: a library for \(\omega \)Words, automata, and LTL. In: Lahiri, S.K., Wang, C. (eds.) ATVA 2018. LNCS, vol. 11138, pp. 543–550. Springer, Cham (2018). https://doi.org/10.1007/9783030010904_34
Li, Y., Turrini, A., Zhang, L., Schewe, S.: Learning to complement Büchi automata. VMCAI 2018. LNCS, vol. 10747, pp. 313–335. Springer, Cham (2018). https://doi.org/10.1007/9783319737218_15
Oura, R., Sakakibara, A., Ushio, T.: Reinforcement learning of control policy for linear temporal logic specifications using limitdeterministic Büchi automata. CoRR, abs/2001.04669 (2020)
Pelánek, R.: BEEM: benchmarks for explicit model checkers. In: Bošnački, D., Edelkamp, S. (eds.) SPIN 2007. LNCS, vol. 4595, pp. 263–267. Springer, Heidelberg (2007). https://doi.org/10.1007/9783540733706_17
Piterman, N.: From nondeterministic Büchi and Streett automata to deterministic parity automata. In: LICS 2006, pp. 255–264. IEEE Computer Society (2006)
Safra, S.: On the complexity of omegaautomata. In: FOCS 1988, pp. 319–327. IEEE Computer Society (1988)
Sickert, S., Křetínský, J.: MoChiBA: probabilistic LTL model checking using limitdeterministic Büchi automata. In: Artho, C., Legay, A., Peled, D. (eds.) ATVA 2016. LNCS, vol. 9938, pp. 130–137. Springer, Cham (2016). https://doi.org/10.1007/9783319465203_9
Sickert, S., Esparza, J., Jaax, S., Křetínský, J.: Limitdeterministic Büchi automata for linear temporal logic. In: Chaudhuri, S., Farzan, A. (eds.) CAV 2016. LNCS, vol. 9780, pp. 312–332. Springer, Cham (2016). https://doi.org/10.1007/9783319415406_17
Somenzi, F., Bloem, R.: Efficient Büchi automata from LTL formulae. In: Emerson, E.A., Sistla, A.P. (eds.) CAV 2000. LNCS, vol. 1855, pp. 248–263. Springer, Heidelberg (2000). https://doi.org/10.1007/10722167_21
Tsai, M.H., Tsay, Y.K., Hwang, Y.S.: GOAL for games, omegaautomata, and logics. In: Sharygina, N., Veith, H. (eds.) CAV 2013. LNCS, vol. 8044, pp. 883–889. Springer, Heidelberg (2013). https://doi.org/10.1007/9783642397998_62
Vardi, M.Y.: Automatic verification of probabilistic concurrent finitestate programs. In: FOCS 1985, pp. 327–338. IEEE Computer Society (1985)
Weibel, D.: Empirical performance investigation of a Büchi complementation construction. Master’s thesis, University of Fribourg (2015)
Acknowledgment
F. Blahoudek has been supported by the DARPA grant D19AP00004 and by the F.R.S.FNRS grant F.4520.18 (ManySynth). J. Strejček has been supported by the Czech Science Foundation grant GA1924397S.
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
Rights and permissions
Open Access This chapter is licensed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license and indicate if changes were made.
The images or other third party material in this chapter are included in the chapter's Creative Commons license, unless indicated otherwise in a credit line to the material. If material is not included in the chapter's Creative Commons license and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder.
Copyright information
© 2020 The Author(s)
About this paper
Cite this paper
Blahoudek, F., DuretLutz, A., Strejček, J. (2020). Seminator 2 Can Complement Generalized Büchi Automata via Improved Semideterminization. In: Lahiri, S., Wang, C. (eds) Computer Aided Verification. CAV 2020. Lecture Notes in Computer Science(), vol 12225. Springer, Cham. https://doi.org/10.1007/9783030532918_2
Download citation
DOI: https://doi.org/10.1007/9783030532918_2
Published:
Publisher Name: Springer, Cham
Print ISBN: 9783030532901
Online ISBN: 9783030532918
eBook Packages: Computer ScienceComputer Science (R0)