Bchi automaton

Union: There is a Bchi automaton that recognizes

the language L(A)L(B).

In computer science and automata theory, a Bchi automaton is a type of -automaton, which extends a nite
automaton to innite inputs. It accepts an innite input
sequence i there exists a run of the automaton that visits (at least) one of the nal states innitely often. Bchi
automata recognize the omega-regular languages, the innite word version of regular languages. It is named after the Swiss mathematician Julius Richard Bchi who
invented this kind of automaton in 1962.[1]

Proof: If we assume, w.l.o.g., QAQB

is empty then L(A)L(B) is recognized by
the Bchi automaton (QAQB, , AB,
IAIB, FAFB).
Intersection: There is a Bchi automaton that recognizes the language L(A)L(B).

Bchi automata are often used in model checking as an

automata-theoretic version of a formula in linear temporal logic.

Proof:
The
Bchi
A'=(Q',,',I',F') recognizes
where

Formal denition

Formally, a deterministic Bchi automaton is a tuple A

= (Q,,,q0 ,F) that consists of the following components:

Q' = QA QB {1,2}
' = 1 2
1 = {( (qA,qB,1), a, (q'A,q'B,i) ) |
(qA,a,q'A)A and (qB,a,q'B)B and
if qAFA then i=2 else i=1 }
2 = {( (qA,qB,2), a, (q'A,q'B,i) ) |
(qA,a,q'A)A and (qB,a,q'B)B and
if qBFB then i=1 else i=2 }

Q is a nite set. The elements of Q are called the

states of A.
is a nite set called the alphabet of A.
: Q Q is a function, called the transition
function of A.

I' = IA IB {1}
F' = { (qA,qB,2) | qBFB }

q0 is an element of Q, called the initial state.

By
construction,
r'=(qA0 ,qB0 ,i0 ),(qA1 ,qB1 ,i1 ),... is a run of automaton A' on input word w i rA=qA0 ,qA1 ,...
is run of A on w and rB=qB0 ,qB1 ,... is run of
B on w. rA is accepting and rB is accepting
i r' is concatenation of an innite series of
nite segments of 1-states(states with third
component 1) and 2-states(states with third
component 2) alternatively. There is such a
series of segments of r' i r' is accepted by A'.

FQ is the acceptance condition. A accepts exactly

those runs in which at least one of the innitely often
occurring states is in F.
In a non-deterministic Bchi automaton, the transition
function is replaced with a transition relation that returns a set of states. Generally, Bchi automaton refers
to non-deterministic Bchi automaton.
For more comprehensive formalism see also automaton.

automaton
L(A)L(B),

Concatenation: There is a Bchi automaton that

recognizes the language L(C) L(A).

Closure properties

Proof: If we assume, w.l.o.g., QCQA

is empty then the Bchi automaton
A'=(QCQA,,',I',FA)
recognizes
L(C)L(A), where

The set of Bchi automata is closed under the following

operations.
Let A=(QA,,A,IA,FA) and B=(QB,,B,IB,FB) be
Bchi automata and C=(QC,,C,IC,FC) be a nite automaton.

' = A C { (q,a,q') | q'IA and fFC.

(q,a,f)C }

4
if ICFC is empty then I' = IC otherwise I' =
IC IA
-closure: If L(C) does not contain empty word then
there is a Bchi automaton that recognizes the language L(C) .
Proof: The Bchi automaton that recognizes
L(C) is constructed in two stages. First, we
construct a nite automaton A' such that A'
also recognizes L(C) but there are no incoming
transitions to initial states of A'. So, A'=(QC
{q },,',{q },FC), where ' = C {
(q ,a,q') | qIC. (q,a,q')C}. Note that
L(C)=L(A') because L(C) does not contain the
empty string. Second, we will construct the
Bchi automaton A that recognize L(C) by
adding a loop back to the initial state of A'. So,
A"=(QC {q },,",{q },{q }), where
" = ' { (q,a,q ) | q'FC. (q,a,q')'}.

ular, there is no deterministic Bchi automaton that recognizes the language (0+1)*0 (Any word that has an innite sux consisting of only 0s). We can demonstrate
it by contradiction that no such deterministic Bchi automaton exists. Let us suppose A is a deterministic Bchi
automaton that recognize (0+1)*0 with nal state set
F. A accepts 0 . So, A will visit some state in F after
reading some nite prex of 0 , say after the i0 th letter.
A also accepts the -word 0i0 10 . Therefore, for some
i1 , after the prex 0i0 10i1 the automaton will visit some
state in F. Continuing with this construction the -word
0i0 10i1 10i2 ... is generated which causes A to visit some
state in F innitely often and the word is not in (0+1)*0 .
Contradiction.
The class of languages recognizable by deterministic
Bchi automata is characterized by the following lemma.
Lemma: An -language is recognizable by a
deterministic Bchi automaton i it is the limit
language of some regular language.

Complementation:There is a Bchi automaton that

recognizes the language /L(A).
Proof: The proof is presented here.

ALGORITHMS

Recognizable languages

Bchi automata recognize the -regular languages. Using the denition of -regular language and the above
closure properties of Bchi automata, it can be easily
shown that a Bchi automaton can be constructed such
that it recognizes any given -regular language. For
converse, see construction of a -regular language for a
Bchi automaton.

Proof: Any deterministic Bchi automaton A

can be viewed as a deterministic nite automaton A' and vice-versa, since both types of automaton are dened as 5-tuple of the same
components, only the interpretation of acceptance condition is dierent. We will show that
L(A) is the limit language of L(A'). An -word
is accepted by A i it will force A to visit nal
states innitely often. I, innitely many nite
prexes of this -word will be accepted by A'.
Hence, L(A) is a limit language of L(A').

4 Algorithms

Model checking of nite state systems can often be translated into various operations on Bchi automata. In adDeterministic versus non-deterministic Bchi automatadition to the closure operations presented above, the following are some useful operations for the applications of
Bchi automata.

0
q

0
0

Determinization
Since deterministic Bchi automata are strictly less expressive than non-deterministic automata, there can not
be an algorithm for determinization of Bchi automata.
But, McNaughtons Theorem and Safras construction
provide algorithms that can translate a Bchi automaton
into a deterministic Muller automaton or deterministic
Rabin automaton.

1
A non-deterministic bchi automaton that recognizes (0+1)*0

Emptiness checking

The language recognized by a Bchi automaton is nonThe class of deterministic Bchi automata does not suf- empty if and only if there is a nal state that is both reachce to encompass all omega-regular languages. In partic- able from the initial state, and lies on a cycle.

3
' = { ( (q,i), a, (q',j) ) | (q,a,q') and if q
F then j=((i+1) mod n) else j=i }

An eective algorithm that can check emptiness of a

Bchi automaton:

F'=F1 {1}
1. Consider the automaton as a directed graph and decompose it into strongly connected components.
From Linear temporal logic formula A translation
from a Linear temporal logic formula to a gen2. Run a search (e.g., the depth-rst search) to nd
eralized Bchi automaton is given here. And, a
which components are reachable from the initial
translation from a generalized Bchi automaton to
state.
a Bchi automaton is presented above.
3. Check whether there is a non-trivial strongly connected component that is both reachable and con- From Muller automata A given Muller automaton can
tains a nal state.
be transformed into an equivalent Bchi automaton with following automata construction. Lets suppose A = (Q,,,Q0 ,{F0 ,...,F }) is a Muller automaton, where F0 ,...,F are sets of accepting states. An
equivalent Bchi automaton is A' = (Q', , ',Q0 ,F'),
where

Each of the steps of this algorithm can be done in time

linear in the automaton size, hence the algorithm is clearly
optimal.
Minimization

The algorithm for minimizing nondeterministic nite automaton also correctly minimizes a Bchi automaton.
The algorithm does not guarantee minimum Bchi automaton. However, the algorithms for minimizing deterministic nite automaton does not work for deterministic
Bchi automaton.

Variants
Co-Bchi automaton
Weak Bchi automaton
Semi-deterministic Bchi automaton
Generalized Bchi automaton

Transforming
from
other
models of description to nondeterministic Bchi automata

From generalized Bchi automata (GBA)

Multiple sets of states in acceptance condition can be translated into one set of
states by an automata construction, which is
known as counting construction. Lets say
A = (Q,,,q0 ,{F1 ,...,F }) is a GBA, where
F1 ,...,F are sets of accepting states then the
equivalent Bchi automaton is A' = (Q', ,
',q'0 ,F'), where

Q' = Q {1,...,n}
q'0 = ( q0 ,1 )

Q' = Q n {i} F 2F
'= 1 2 , where
1 ={ ( q, a, (i,q',) ) | (q, a, q') and
q' F }
2 ={ ( (i,q,R), a, (i,q',R') ) | (q,a,q')
and q,q' F and if R=F then R'= otherwise R'=R{q} }
F'=n {i} F {F}
A' keeps original set of states from A and adds
extra states on them. The Bchi automaton A'
simulates the Muller automaton A as follows:
At the beginning of the input word, the execution of A' follows the execution of A, since
initial states are same and ' contains . At
some non-deterministically chosen position in
the input word, A' decides of jump into newly
added states via a transition in 1 . Then, the
transitions in 2 try to visit all the states of Fi
and keep growing R. Once R becomes equal to
Fi then it is reset to the empty set and 2 try to
visit all the states of Fi states again and again.
So, if the states R=Fi are visited innitely often then A' accepts corresponding input and
so does A. This construction closely follows the
rst part of the proof of McNaughtons Theorem.

From Kripke structures Let the given Kripke structure

be dened by M = <Q, I, R, L, AP> where Q is the
set of states, I is the set of initial states, R is a relation
between two states also interpreted as an edge, L is
the label for the state and AP are the set of atomic
propositions that form L.
The Bchi automaton will have the following
characteristics:

8
Qnal = Q {init}
= 2AP
I = {init}
F = Q {init}

= q
a p if (q, p) belongs to R and
L(p) = a

and init
a q if q belongs to I and L(q) = a.
Note however that there is a dierence in the
interpretation between Kripke structures and
Bchi automata. While the former explicitly
names every state variables polarity for every state, the latter just declares the current
set of variables holding or not holding true. It
says absolutely nothing about the other variables that could be present in the model.

References

[1] Bchi, J.R. (1962). On a decision method in restricted

second order arithmetic. Proc. International Congress on
Logic, Method, and Philosophy of Science. 1960 (Stanford: Stanford University Press): 112.

Thomas, Wolfgang (1990). Automata on innite

objects. In Van Leeuwen. Handbook of Theoretical
Computer Science. Elsevier. pp. 133164.

External links
Finite-state Automata on Innite Inputs.
Vardi, Moshe Y. An automata-theoretic approach to linear temporal logic.
CiteSeerX:
10.1.1.125.8126.

EXTERNAL LINKS

Text and image sources, contributors, and licenses

9.1

Text

Bchi automaton Source: http://en.wikipedia.org/wiki/Bchi_automaton?oldid=623465611 Contributors: The Anome, Edward, Michael

Hardy, Ahoerstemeier, Charles Matthews, Dysprosia, Michaeln, David.Monniaux, Phil Boswell, Rholton, Qlmatrix, Sam Hocevar, Gedeon,
BlueNovember, Philipp Weis, Gene Nygaard, Oleg Alexandrov, Ruud Koot, Chris Pressey, Mathbot, TheGrappler, DaltonSerey, Zwobot,
Bluebot, Octahedron80, Colonies Chris, NongBot, Misof, Cydebot, Amalmanuel, Hermel, Skomorokh, Grokmenow, Dricherby, A3 nm,
LordAnubisBOT, MkClark, Idioma-bot, Phisches, Mild Bill Hiccup, Addbot, Peni, Yobot, LilHelpa, Xqbot, Ashutosh y0078, Helptry,
28bot, ChrisGualtieri, Mark viking and Anonymous: 28

9.2

Images

File:Buchi_non_deterministic_example.svg Source: http://upload.wikimedia.org/wikipedia/commons/0/02/Buchi_non_deterministic_

example.svg License: CC-BY-3.0 Contributors: Own work Original artist: Ashutosh y0078

9.3

Content license

Creative Commons Attribution-Share Alike 3.0