Converting A Subset of LTL Formula to Buchi Automata

International Journal of Software Engineering & Applications (IJSEA), Vol.10, No.2, March 2019
DOI: 10.5121/ijsea.2019.10204 35
CONVERTING A SUBSET OF LTL FORMULA TO
BUCHI AUTOMATA
Bilal Kanso and Ali Kansou
Department of Computer Science, Lebanese University, Beirut
ABSTRACT
The translation of LTL formula into equivalent Büchi automata plays an important role in many algorithms
for LTL model checking, which consist in obtaining a Büchi automaton that is equivalent to the software
system specification and another one that is equivalent to the negation of the property. The intersection of
the two Büchi automata is empty if the model satisfies the property.
Generating the Büchi automaton corresponding to an LTL formula may, in the worst case, be exponential
in the size of the formula, making the model checking effort exponential in the size of the original formula.
There is no polynomial solution for checking emptiness of the intersection. That comes from the translation
step of LTL formula into finite state models. This makes verification methods hard or even impossible to be
implemented in practice. In this paper, we propose a subset of LTL formula which can be converted to
Büchi automata whose the size is polynomial.
KEYWORDS
Linear Temporal Logic, Büchi automata, Model checking, Compositional modelling.
1. INTRODUCTION
Model checking becomes increasingly one of the most important tools to verify the correctness of
computer-based control systems [1, 4, 12, 15]. It is a formal verification technique consisting in
algorithmically verifying whether system properties such as the absence of deadlocks (described
in some appropriate logical formalism such as temporal logic) are satisfied by the system
(described as a suitable finite state model). The success of the model checking technique comes
from the fact that it is completely automatic. Running a model checking on a given system model
to verify a desired property leads automatically to fail state or successful state. In case the system
model fails to satisfy the property, the model checking tool can offer a counterexample which can
be used as an error trace provided for debugging purposes.
Model checking approaches vary according to the logic used to specify system properties [3, 12,
18, 21]. One of the most used logics is the Linear Temporal Logic (LTL) [11, 20]. The underlying
idea consists in transforming the negation of the LTL expression into a Büchi automaton, and
then computing the product between the Büchi automaton representing the system and the one
representing the negation of the LTL expression. If the product is not empty, that means the
property expressed by the negation of the LTL expression is not satisfied by the system,
otherwise the property is well-satisfied. However, the decision problem for emptiness of the
intersection is PSPACE-hard [2, 19]. That comes from the translation of LTL formula into Büchi
automata. Indeed, the space complexity of this approach is linear in the size of Büchi automata
and exponential in the length of the LTL formula: the Büchi automaton of a property (described
as a LTL formula) is constructed in exponential space in the length of this property [22]. This

36
makes verification methods hard or even impossible to be implemented in practice and makes the
scalability of the LTL model checking limited, which commonly referred to as the state explosion
problem [8].
In this paper, we contribute to finding a subset of LTL properties that can be converted
polynomially into Büchi automata. Finding such a subset of LTL logic will be viewed as one the
most promising directions to bridge the gap between the increasing complexity of state models
and actual model checking methods. We define a fragment that we call, Flat LTL Logic and we
show how formula in this fragment can be transformed into Büchi automata whose the state space
size is linear. Due to the structure of flat LTL formula, our algorithm can be compositional in the
sense that the final finite state model associated to a given formula is obtained by developing a
sub-automaton for each sub-formula of the principal formula. Hence, the basic idea for
developing the final automaton for a flat LTL formula f is that f can be recursively decomposed
into a set of sub-formula, arriving at sub-formula that can be completely handled. Composition is
then used for assembling different sub-automata and then forming larger ones. Such a
composition can be seen as an operation taking sub-automata for sub-formula as well as the flat
LTL operator to provide a new more complex automaton.
In order to guide the construction of the final automaton for a flat LTL formula f from the sub-
automata associated to the sub-formula f1, f2, … , fn of f, we build the finite syntax tree,
FST(f) of the formula f. The nodes of a finite syntax tree are labelled, either by flat LTL
operators or by propositional operators. The leaves are labelled only by atomic propositions.
Thus, the target Büchi automaton is obtained by exploring the tree in pre-order.
The rest of this article is organized as follows: Section 2 briefly describes Büchi automata. In
Section 3, we describe our fragment of LTL logic and the reasons to choose it. In Section 4, we
present for each formula in our fragment LTL, its equivalent Büchi automata and show the proof
of this equivalence. Section 5 presents the finite syntax tree associated to a formula defined in our
fragment LTL while Section 6 shows the final algorithm that generates to any formula in our
fragment an equivalent Büchi automaton. Section 7 presents the conclusion and some future
works.
2. AUTOMATA ON INFINITE WORDS
2.1. Büchi automata
Automata on infinite inputs were introduced by Büchi. A Büchi automaton is a non- deterministic
finite-state automaton which takes infinite words as input [9, 10, 14]. A word is accepted if the
automaton goes through some designated “good” states infinitely often while reading it. A Büchi
automaton is a finite state automaton defined by a 5-tuple A = (S, s0, F, ∑, δ ) where:
 S is a finite set of states,
 s0 ∈ S is the initial state,
 Σ is a non-empty set of atomic propositions,
 F ⊆ S is a finite set of accepting states,
 Δ : S × Σ → 2S
is a transition function.
In the following of this paper, the initial state of a Büchi automaton is pointed to by incoming
arrows and the accepting states are marked by double circles.

37
A run of A on σ =σ (0)σ(1)σ(2) … ∈ Σω
is an infinite sequence of states s0s1s2 … ∈ Sω
starting
with the initial state s0 of A such that ∀i, i ≥ 0, si+1 ∈ δ(si, σ(i)). A run s0s1s2 … is accepting by an
automaton A if A goes through accepting states (i.e. ∈ F) infinitely often while reading it. The
accepted language of a Büchi automaton A, denoted by ℒω(A), is then defined by ℒω(A) = { σ in
Σω
| there is an accepting run for σ in A }.
2.2. Operations on Büchi automata
The basic idea of the construction of the union of two Büchi automata A1 and A2 is to add a new
initial (nonaccept) state snew to the set of states union of A1 and A2. The transitions of the union of
A1 and A2 are transitions of both A1 and A2 with the following transitions:
a) A transition from snew to a state s labelled with a proposition p if and only if there is
transition from the initial state of A1 to the state s labelled with the proposition p;
b) A transition from snew to a state s labelled with a proposition p if and only if there is
transition from the initial state of A2 to the state s labelled with the proposition p
The construction of the intersection automaton works a little differently from the finite state
automata case. One needs to check whether both sets of accepting states are visited infinitely
often. Consider two runs r1 and r2 and a word σ where r1 goes through an accept state after σ(0),
σ(2), ⋯ and r2 enters accept state after σ(0) σ(3) ⋯. Thus, there is no guarantee that r1 and r2 will
enter accept states simultaneously. To overcome this problem, we need to identify the accept
states of the intersection of the two automata. To do so, we create two copies of the intersected
state space. In the first copy, we check for occurrence of the first acceptance set. In the second
copy, we check for occurrence of the second acceptance set. When a run enters a final state in the
first copy, we wait for that run also enters in an accept state in the second copy. When this is
encountered, we switch back to the first copy and so on. We repeat jumping back and forth
between the two copies whenever we find an accepting state.

38
3. Flat LTL LOGIC
In this section, we introduce our subset of LTL logic that we call Flat LTL Logic. This fragment
will be used to express temporal properties and then translate them into Büchi automata in linear
size. The syntax of our Flat LTL logic adds to usual boolean propositional operators ¬ (negation)
and ∧ (conjunction), some modal operators that describe how the behaviour changes with time.
 Next: Xφ requires that the formula φ be true in the next state;
 Until: φ1 U φ2 requires that the formula φ1 be true until the formula φ2 is true, which is
required to happen;
 Eventually: ◊φ requires that the formula φ be true at some point in the future (starting
from the present) and it is equivalent to ◊ φ ≡ true U φ;
 Release: φ1 R φ2 requires that its second argument φ2 always be true, a requirement that
is released as soon as its first argument φ1 becomes true. It is equivalent to φ1 R φ2 ≡ ¬
(¬ φ1 U ¬ φ2).
3.1. Our fragment LTL logic

39
Example : the formula X(a U ¬(d R (¬ b U X c))) is not in ℒf since the sub-formula (¬b U X c) in
¬(d R (¬b U X c)) should be of the form Δ U θ that is not the case. But, the formula X(a U ¬ (d R
(¬ b R X c))) is in ℒf.
For the sake of brevity and the lack of space, we only discuss here why the fragment θ U φ is
included within our LTL fragment to the detriment of both formula φ1U φ2 and φ1 U θ. It is well-
known the size of an Büchi automaton A that recognizes the complement language ℒω( A ) of
the language accepted ℒω(A) by an automaton A is exponential [13, 16]. Suppose we have
separately built an automaton A1 for φ1 and an automaton A2 for φ2, and let us then try to
compositionally obtain the resulting automaton A for φ. According to the until operator's
semantics, it is required that φ holds at the current moment, if there is some future moment for
which φ2 holds and φ1 holds at all moments until that future moment. That means constructing the
automaton for φ = φ1 U φ2 firstly requires constructing of the intersection of A1 and A2 . As
stated previously, computing A2 is exponential and therefore, constructing the Büchi automaton
for φ1 U φ2 is exponential. To avoid this kind of formula, we choose the formula θ U φ to be a
part of our LTL subset where the construction of the Büchi automaton associated to it, does not
need to complement any Büchi automaton.
3.2 Flat Positive Normal Form (FPNF)
As LTL formula, flat LTL formula can be transformed into the so-called Flat Positive Normal
form (FPNF). This form is characterized by the fact that negations only occur adjacent to atomic
propositions. All negation symbols of the given LTL formula have to be pushed inwards over the
temporal operators.
Each formula φ ∈ ℒf can be transformed into a formula φ′ ∈ ℒFPNF. This is done by pushing
negations inside, near to atomic propositions. To do this, we use the following transformation
rules:
¬ true → false
¬ Xφ → X ¬φ
¬ ¬ φ → φ
¬ (φ U θ) → ¬φ R ¬θ
¬ (φ1 ∧ φ2) → ¬φ1 ∨ ¬ φ2
¬ (θ R φ) → ¬θ U ¬φ
This transformation is done in linear complexity as it is shown by the following theorem:
Example: the formula X(a U ¬(d R (¬ b R Xc))) is in ℒf, but not in ℒFPNF. It can be transformed
into X (a U (¬d U (b U X ¬c))) which is in ℒFPNF.

40
3.3 Semantics
The semantics of LTL formula is defined over infinite sequences σ : ℕ → 2Σ. In other words, a
model is an infinite sequence A0 A1 ⋯ of subsets of Σ. The function σ, called interpretation
function, describes how the truth of atomic propositions changes as time progresses. For every
sequence σ, we write σ = (σ(0), ⋯, σ(n), ⋯). Thus, we have the following two notations:
 σ(i) denotes the state at index i and σ(i:j) the part of σ containing the sequence of states
between i and j;
 σ(i…) =Ai Ai+1 Ai+2 ⋯ denotes the suffix of a sequence σ = A0 A1 A2 ⋯ ∈ (2Σ)ω
starting in the ( i+1)st symbol Ai.
We also write σ(i) ⊨ φ to denote that "φ is true at time instant i in the model σ". This notion is
defined inductively, according to the structure of φ.
The LTL formula are interpreted over infinite sequences of states σ: ℕ → 2Σ as follows:
1
2Σ is the power set of the proposition set Σ.
2
ω: is typically used to denote infinity
4. CONSTRUCTION OF BUCHI AUTOMATA FOR FLAT LTL LOGIC
Our algorithm is a compositional algorithm. It constructs for each sub-formula in our fragment
LTL logic, an equivalent Büchi automaton and in a compositional way regroup all resulting Büchi
automata in order to get the target Büchi automaton of the target flat LTL formula.
In the sequel, we firstly explain for each sub-formula in our fragment LTL logic how its
equivalent Büchi automaton can be obtained.
4.1. Büchi automata for θ formula
The Büchi automaton associated to a propositional formula θ is obtained by creating two states s0
and s1 and two transitions tr1 and tr2. s0 is the only initial state while s1 is the only final state. tr1 is
the transition from s0 to s1 labelling with θ while the transition tr2 is a loop labelled with true over
the state s2.
Figure 1 shows the Büchi automaton associated to the propositional formula θ = a ∧ ¬b.
Figure 1: Example of automaton associated to θ

41
4.2. Büchi automata for θ U φ formula
The main idea behind the composition θ U φ is to add a new initial (nonaccept) state snew to the set
of states of the automaton Aφ associated to φ with the following transitions:
a) A loop over the added state snew labelled with the propositional formula θ
b) Transitions snew to a state s labelled with a proposition p if and only if there a transition
from the initial state s0
of Aφ to the state s labelled with the proposition p .
All other transitions of Aφ, as well as the accept states, remain unchanged. The state snew is the
single initial state of the resulting automaton, is not accept, and, clearly, has no incoming
transitions except the loop one.
Example: Figure 2 illustrates the composition definition of θ U φ. Figure 2a shows the Büchi
automaton associated to (◊ b) R c. To construct the Büchi automaton associated to (a U ((◊ b) R
c)), we add a new state snew that we consider as initial state. Then, for each transition outgoing
from snew with label l and goes to state s, we add a transition from snew to the state s with a label l.
Finally, we then add a loop labelled with the atomic proposition a over the added state.
Figure 2: Example of composition: θ U φ

42
Eventually operator ◊φ: the Büchi automaton construction of the formula ◊φ is a particular case
of the Büchi automaton construction of the formula θ U φ where θ is the true formula. Thus, the
main idea behind the composition ◊φ is to add a new initial (nonaccept) state snew to the
automaton states set Aφ associated to φ with the same transitions defined for θ U φ where the
loop over the added state snew is labelled with true instead of the atomic formula θ.
4.3. Büchi automata for Xφ formula
The main idea behind the composition Xφ consists in adding two new states snew (neither initial
state or accept state) and sinit (considered as the initial state) to the state set of the automaton Aφ
with the following transitions:
a) Add for any transition in Aφ which starts from the initial state s0
to a state s, a transition
from snew to s;
b) Add a transition from the initial state sinit to the snew labelled with true.
All other transitions of Aφ remain unchanged and final states of Aφ become accept ones of Aψ and
initial state of Aψ become the state sinit.
Example: Figure 3 illustrates the definition of Xφ. Figure 3a shows the Büchi automaton
associated to the formula (a U (X b R c)). To construct the Büchi automaton equivalent to X(a U
(Xb R c)), we add a new state snew and for each transition tr starting from the initial state s0
φ to a
state s, a transition from snew to s with the same label. Finally, we add the state sinit that we
consider as initial and we connect sinit to snew with a transition labelled with the true label.
Figure 3: Example of composition: Xφ

43
4.4. Büchi automata for φ R θ formula
The formula φ R θ informally means that θ is true until φ becomes true, or θ is true forever. Thus,
the construction of a Büchi automaton for φ R θ can be done by construction the Büchi
automaton associated to the fact that θ is true until φ becomes true and the construction of a
Büchi automaton associated to the fact that θ is true forever. Finally, make the union between the
two constructed Büchi automata. Consequently, to build the Büchi automaton for φ R θ, we need
to add two new states si and sf to the set of states of the automaton Aφ. si becomes the single initial
state of the resulting automaton and sf is added to set of final states of the resulting automaton.
The following transitions are added to the set of transitions of the resulting automaton:
a) For any transition from the initial state s0
of Aφ to a state s labelled with a proposition p,
add a transition from the state si to s labelled with the proposition p ∧ θ;
b) A loop over the added state si labelled with the propositional formula θ;
c) A loop over the added state sf labelled with the propositional formula θ;
d) A transition from the state si to the state sf labelled with the proposition θ.
All other transitions of Aφ, as well as the accept states, remain unchanged.
Example: Figure 4 illustrates the composition definition of φ R θ. Figure 4a shows the Büchi
automaton associated to the formula c U ◊b. To construct the Büchi automaton associated to the
flat LTL formula ((c U ◊b) R a), we add a state si that we consider as the only initial state and a
state sf that we consider as a final state. We add a loop labelled with the atomic proposition $a$
over the two added states. Finally, for each transition outgoing from the initial state of the
automaton φ with label l and goes to state s, we add a transition from the added state si to the state
s with a label (l ∧ a). We also add a transition labelled with a from the state si to the state sf.

44
Figure 4: Example of composition: φ R θ
5. FINITE SYNTAX TREE OF FLAT LTL FORMULA
A flat LTL formula φ can be transformed into a tree containing all the information about the
possible sub-formula of φ. It will form the cornerstone of the construction of Büchi automata
from flat LTL formula. We assume that our flat LTL formula are fully parenthesized and we
show how to build the finite syntax tree, named FST(φ), algorithmically for a flat LTL formula φ.
This tree can be thought of as a data structure representing the sub-formula after a finite breaking
up the formula into a list of tokens. We distinguish four kinds of tokens: left brackets "(", right
brackets ")", FLTL operators and propositional variables. FLTL operators represent the internal
nodes of our tree while the propositional variables represent the leaf nodes. Our algorithm to build
FST(φ) is inspired from [5] and uses a stack for operators and a stack for propositional variables,
and consists of the following rules:
a) If the current token is a left bracket "(" (i.e. we are reading a new sub-formula), push it on
the operator stack;
b) If the current token is a operator (i.e. in {'∧', '∨', 'X', 'U', ‘◊', 'R', '¬' }), push it on the
operator stack;
c) If the current token is a propositional variable p, create a tree with single node whose the
value is p and push the created tree on the variable stack;
d) If the current token is a right bracket ")" (i.e. we have just finished reading a sub-
formula), pop operators off the operator stack while this operator is not a left bracket. If
the popped operator is an unary operator, pop one tree variable from variable stack and
create new tree whose the root is the popped operator and it is only child is the popped
tree. If the popped operator is a binary operator, pop two tree variables from variable
stack and create new tree whose the root is the popped operator and its right child the first
popped tree and its left child the second popped tree. If no left bracket is found during
popping the variable stack, throw a mismatched bracket expression. Otherwise, pop found
left bracket from the operator stack;
e) At the end of reading expression tokens, pop all operators off the operator stack and for
each popped operator:

45
 If the popped operator is an unary operator, pop one tree variable from variable
stack and create new tree whose the root is the popped operator and it is only
child is the popped tree. Then, push the created tree on the variable stack;
 If the popped operator is a binary operator, pop two tree variables from variable
stack and create new tree whose the root is the popped operator and its right child
the first popped tree and its left child the second popped tree. Then, push the
created tree on the variable stack;
 If the popped operator is left or right bracket, throw an unbalanced left bracket.
Hence, our mechanism of creating FST(φ) can be described by the algorithm illustrated in Figure
5:
Figure 5: Building syntax tree for a FLTL formula

46
Example: Figure 6a shows the finite syntax tree FST(φ) generated for the FLTL expression:
φ = ◊ a → (b → ((¬f) U (d ∧ (¬e)))) R c.
Figure 6: Example of finite syntax tree
This finite syntax tree will be used to construct the Büchi automaton equivalent to a flat LTL
formula φ in flat positive normal form. Since our algorithm takes as input a flat positive LTL
formula, any node in the finite syntax tree labelled with the negation operator ¬ is certainly
located directly before a leaf. For technical reasons, we merge the nodes labelled with ¬ with the
leaf which directly follows in the finite syntax tree. Figure 6b illustrates the finite syntax tree
presented in Figure 6a after pushing negations to leaves.
6. FROM FINITE SYNTAX TREE TO BUCHI AUTOMATA
Our algorithm to build Büchi automata from flat LTL formula is compositional in the sense that
the final Büchi automaton is obtained by developing a sub-automaton for each sub-formula of the
principal formula. Hence, the basic idea for developing the final automaton for a flat LTL formula
φ is to explore FST(φ) in a pre-order traversal. That is to say, we visit the root node first, then
recursively do a pre-order traversal of the left sub-tree, followed by a recursive pre-order traversal
of the right sub-tree. The algorithm, illustrated in Figure 7, allows us to build a Büchi automaton
from a finite syntax tree of a positive flat LTL formula T=FST(φ) and uses the following five
functions:
a) CreateBuchiProp(θ): takes as input a propositional formula θ and returns the automaton
as defined in Definition 6 (Section 4);
b) CreateBuchiUnary(op, BA): takes as input an unary LTL formula (i.e. op ∈ {X, ◊}) and
a Büchi automaton BA and returns a Büchi automaton defined according to definitions of
◊ and X given in Section 4;
c) CreateBuchiBinary(op, BAl,BAr): that takes as input ∧ or ∨ operator and two Büchi
automata BAl and BAr and returns a Büchi automaton defined according to definitions of
∧ and ∨ given in Section 2;
d) BuchiUntil(θ, BA): that takes as input a propositional formula θ and a Büchi automaton
BA and returns the automaton as defined in Definition 7 (Section 4);
e) BuchiRelease(θ, BA): that takes as input a propositional formula θ and a Büchi
automaton BA and returns the automaton as defined in Definition 9 (Section 4).

47
Figure 7: building buchi automata: buildBA(T)
7. CONCLUSION AND FUTURE WORK
This paper presents a compositional algorithm for generating Büchi automata from a fragment of
LTL logic. We firstly proposed the grammar of this fragment and then built for each formula φ,
its equivalent automata. We secondly showed how to compositionally build from Büchi automata
associated to each sub-formula, the Büchi automaton of the target formula. We thirdly showed the
complexity and the correctness of our Büchi automata generation method.
Future work: several research lines can be continued from the present work. First, some
temporal operators such as always, precedes or since are not considered in this paper, as an
immediate perspective, we will study how to include these operators in our LTL fragment.
Second, Dwyer's presents a translational semantics for his pattern properties. Indeed, for each
pattern property, he associates an equivalent LTL formula. It will be interesting to study whether
the translational semantics given by Dwyer is covered by our fragment. This will be done by
comparing Büchi automata generated by LTL2BA proposed by Gastin with the Büchi automata
generated by our algorithm.

48
REFERENCES
[1] C. Baier and J.P. Katoen. Principles of Model Checking (Representation and Mind Series). The MIT
Press, 2008.
[2] E. Clarke, O. Grumberg, and K. Hamaguchi. Another look at LTL model checking. In Formal
methods in system design, pages 415-427. Springer-Verlag, 1994.
[3] E. M. Clarke, E. A. Emerson, and A. P. Sistla. Automatic verification of finite state concurrent
systems using temporal logic specifications. ACM Trans. Program. Lang. Syst., 8(2):244-263, April
1986.
[4] Edmund M. Clarke, Jr., Orna Grumberg, and Doron A. Peled. Model Checking. MIT Press,
Cambridge, MA, USA, 1999.
[5] E.W. Dijkstra. An Algol 60 translator for the x1 and Making a translator for Algol 60. Technical
Report 35, Mathematisch Centrum, Amsterdam, 1961.
[6] M.B. Dwyer, G.S. Avrunin, and J.C. Corbett. Property specification patterns for finite-state
verification. In FMSP, pages 7- 15, 1998.
[7] M.B. Dwyer, G.S. Avrunin, and J.C. Corbett. Patterns in property specifications for finite-state
verification. In Proceedings of the 21st International Conference on Software Programming, pages
411 - 420, 1999.
[8] P. Gastin and D. Oddoux. Fast LTL to Buchi automata translation. In Proceedings of the 13th
International Conference on Computer Aided Verification (CAV'01), volume 2102 of LNCS, pages
53- 65, Paris, France, jully 2001. Springer.
[9] V. King, O. Kupferman, and M.Y. Vardi. On the Complexity of Parity Word Automata, pages 276 -
286. Springer Berlin Heidelberg, Berlin, Heidelberg, 2001.
[10] M. Mukund. Finite-state automata on infinite inputs, 1996.
[11] A. Pnueli. The temporal logic of programs. In Proceedings of the 18th Annual Symposium on
Foundations of Computer Science, SFCS '77, pages 46-57, Washington, DC, USA, 1977. IEEE
Computer Society.
[12] J.P. Queille and J. Sifakis. Specification and verification of concurrent systems in cesar. In
Proceedings of the 5th Colloquium on International Symposium on Programming, pages 337 - 351,
London, UK, UK, 1982. Springer-Verlag.
[13] S. Safra. On the complexity of omega-automata. In 29th Annual Symposium on Foundations of
Computer Science, White Plains, New York, USA, 24-26 October 1988, pages 319- 327, 1988.
[14] S. Safra. Complexity of Automata on Infinite Objects. PhD thesis, Weizmann Institute of Science,
Rehovot, Israel, March 1989.
[15] A.P. Sistla and E.M. Clarke. The complexity of propositional linear temporal logics. J. ACM,
32(3):733- 749, july 1985.
[16] A.P Sistla, M.Y. Vardi, and P. Wolper. The complementation problem for Buchi automata with
applications to temporal logic. In Automata, Languages and Programming, pages 465 - 474, Berlin,
Heidelberg, 1985. Springer Berlin Heidelberg.

49
[17] S. Taha, J. Julliand, F. Dadeau, K. Castillos, and B. Kanso. A compositional automata-based
semantics and preserving transformation rules for testing property patterns. Formal Asp. Comput.,
27(4):641 - 664, 2015.
[18] M. Y. Vardi and P.Wolper. An automata-theoretic approach to automatic program verification. In
Proc. 1st Symp. on Logic in Computer Science, pages 332 - 344, Cambridge, June 1986.
[19] M.Y. Vardi. Branching vs. linear time: Final showdown. In Proceedings of the 7th International
Conference on Tools and Algorithms for the Construction and Analysis of Systems, TACAS 2001,
pages 1 - 22, London, UK, 2001. Springer-Verlag.
[20] Laixiang S. Zheng Q, Shengnan L., Renwei R. and Xiao Y. Conversion Algorithm of Linear-Time
Temporal Logic to Buchi Automata. Journal of Software. 9. 10.4304-2014.
[21] Babiak T., Křetínský M., Řehák V. and Strejček J. LTL to Büchi Automata Translation: Fast and
More Deterministic, In Proc of the 18th
International Conference on Tools and Algorithms for the
Construction and Analysis of Systems (TACAS 2012). Pages 95 – 109. Heidelberg. 2012. Springer.
[22] A Jantsch, S. and Norrish, M. In Proceedings of International Conference on Interactive Theorem
Proving (ITP). Verifying the LTL to Büchi Automata Translation via Very Weak Alternating
Automata. Pages 306-323. 2018. Springer.
APPENDIX

50

51

52

Converting A Subset of LTL Formula to Buchi Automata

More Related Content

What's hot (19)

Similar to Converting A Subset of LTL Formula to Buchi Automata (20)

Recently uploaded (20)

Converting A Subset of LTL Formula to Buchi Automata