1 \documentclass[a4paper, pagesize, DIV=calc, smallheadings]{article}
3 %\usepackage[latin1]{inputenc}
4 \usepackage{amsmath, amsthm, amssymb, amsfonts, verbatim}
7 \usepackage{algorithmic}
11 \usepackage[left=3.9cm, right=3.9cm]{geometry}
12 %\usepackage[T1]{fontenc}
16 \renewcommand{\familydefault}{\sfdefault}
17 \renewenvironment{proof}{{\bfseries Proof.}}{}
18 \newcommand{\M}{\mathcal{M}}
19 \newcommand{\N}{\mathbb{N}_0}
20 \newcommand{\F}{\mathcal{F}}
21 \newcommand{\Prop}{\mathcal{P}}
22 \newcommand{\A}{\mathcal{A}}
23 \newcommand{\X}{\mathcal{X}}
24 \newcommand{\U}{\mathcal{U}}
25 \newcommand{\V}{\mathcal{V}}
26 \newcommand{\dnf}{\mathsf{dnf}}
28 \title{\uppercase{\textbf{\Large{A}\large{lgorithmic} \Large{V}\large{erification of} \Large{R}\large{eactive} \Large{S}\large{ystems}}\\
32 \uppercase{{\small{E}\scriptsize{UGEN} \small{S}\scriptsize{AWIN}}\thanks{\lowercase{\scriptsize{\texttt{sawine@informatik.uni-freiburg.de}}}}\\
33 {\em \small{U}\scriptsize{NIVERSITY OF} \small{F}\scriptsize{REIBURG}}\thanks{\tiny{Computer Science Department, Research Group for Foundations of Artificial Intelligence}}\\
34 %{\em \small{C}\scriptsize{omputer} \small{S}\scriptsize{cience} \small{D}\scriptsize{epartment}}\\
35 {\em \small{G}\scriptsize{ERMANY}}}\\
36 %\texttt{\footnotesize{sawine@informatik.uni-freiburg.de}}
38 \date{\textsc{\hfill}}
40 \theoremstyle{definition} %plain, definition, remark, proof, corollary
41 \newtheorem*{def:finite words}{Finite words}
42 \newtheorem*{def:infinite words}{Infinite words}
43 \newtheorem*{def:regular languages}{Regular languages}
44 \newtheorem*{def:regular languages closure}{Regular closure}
45 \newtheorem*{def:omega regular languages}{$\omega$-regular languages}
46 \newtheorem*{def:omega regular languages closure}{$\omega$-regular closure}
47 \newtheorem*{def:buechi automata}{Automata}
48 \newtheorem*{def:automata runs}{Runs}
49 \newtheorem*{def:automata acceptance}{Acceptance}
50 \newtheorem*{def:general automata}{Generalised automata}
51 \newtheorem*{def:general acceptance}{Acceptance}
52 \newtheorem*{def:vocabulary}{Vocabulary}
53 \newtheorem*{def:frames}{Frames}
54 \newtheorem*{def:models}{Models}
55 \newtheorem*{def:satisfiability}{Satisfiability}
56 \newtheorem*{def:fs closure}{Closure}
57 \newtheorem*{def:atoms}{Atoms}
58 \newtheorem*{def:rep function}{Representation function}
59 \newtheorem*{def:next}{Next function}
60 \newtheorem*{def:dnf}{Dijunctive normal form}
61 \newtheorem*{def:positive formulae}{Positive formulae}
64 \newtheorem{prop:vocabulary sat}{Proposition}[section]
65 \newtheorem{prop:general equiv}{Proposition}[section]
66 \newtheorem{prop:computation set=language}{Proposition}[section]
69 \newtheorem{thm:model language}{Theorem}[section]
70 \newtheorem{cor:mod=model language}{Corollary}[thm:model language]
71 \newtheorem{cor:mod=program language}[cor:mod=model language]{Corollary}
72 \newtheorem{thm:model checking}{Theorem}[section]
73 \newtheorem{lem:dnf}{Lemma}[section]
79 %\renewcommand\abstractname{Abstract}
81 The algorithmic verification of reactive systems is based on automata-theoretic model checking. Linear temporal logic accommodates the capability for the characterisation of program specifications. For formulae composed in linear temporal logic, it is possible to construct B\"uchi automata constituting the model space of the specification. The verification of reactive systems is composed of such constructions and intersections of the program and specification automata. This paper provides an introduction to the construction techniques of automata and space-efficient on-the-fly verification methods for reactive systems.
85 \section{Introduction}
88 \section{$\omega$-regular languages}
89 \begin{def:finite words}
90 Let $\Sigma$ be a non-empty set of symbols, called the alphabet. $\Sigma^*$ is the set of all \emph{finite} words over $\Sigma$. A \emph{finite} word $w \in \Sigma^*$ is a \emph{finite} sequence $(v_0,...,v_{n-1})$ of symbols from alphabet $\Sigma$ with length $n = |w|$. $\varepsilon$ denotes the empty word with length $|\varepsilon| = 0$.
91 \end{def:finite words}
93 \begin{def:regular languages}
94 The class of regular languages is defined recursively over an alphabet $\Sigma$:
97 \item $\emptyset$ is regular
98 \item $\{\varepsilon\}$ is regular
99 \item $\forall_{a \in \Sigma}:\{a\}$ is regular
102 \end{def:regular languages}
104 \begin{def:regular languages closure}
105 Let $L_{R_1}, L_{R_2} \in \Sigma^*$ be regular. The class of regular languages is closed under following operations:
109 \item $L_{R_1} \circ L_{R_2}$
110 \item $L_{R_1} \cup L_{R_2}$
111 \item $L_{R_1} \cap L_{R_2}$
112 \item $\overline{L}_{R_1}$ and therefore $L_{R_1} - L_{R_2}$
115 \end{def:regular languages closure}
117 \begin{def:infinite words}
118 $\Sigma^\omega$ is the set of all \emph{infinite} words over $\Sigma$. An \emph{infinite} word $w \in \Sigma^\omega$ is an \emph{infinite} sequence $(v_0,...,v_\infty)$ with length $\infty$. To address the elements of the infinite sequence $w$, we view the word as a function $w : \N \to \Sigma$ with $w(i) = v_i$; thus $w(i)$ denotes the symbol at sequence position $i$ of word $w$; another notation used for $w(i)$ is $w_i$.
119 \end{def:infinite words}
121 \begin{def:omega regular languages}
122 Set $L$ is an $\omega$-language over alphabet $\Sigma$ iff $L \subseteq \Sigma^\omega$. Let $L_R \subseteq \Sigma^*$ be a non-empty regular finite language and $\varepsilon \notin L_R$. A set $L$ is $\omega$-regular iff $L$ is an $\omega$-language and $L = L_R^\omega$.
123 \end{def:omega regular languages}
125 \begin{def:omega regular languages closure}
126 Let $L_{\omega_1}, L_{\omega_2} \subseteq \Sigma^\omega$ be $\omega$-regular languages. The class of $\omega$-regular languages is closed under following operations:
128 \item $L_R \circ L_{\omega_1}$, but \emph{not} $L_{\omega_1} \circ L_R$
129 \item $L_{\omega_1} \cup L_{\omega_2}$, but only \emph{finitely} many times
131 \end{def:omega regular languages closure}
133 \section{B\"uchi automata}
134 \begin{def:buechi automata}
135 A non-deterministic B\"uchi automaton is a tuple $\A = (\Sigma, S, S_0, \Delta, F)$, where $\Sigma$ is a finite non-empty \emph{alphabet}, $S$ is a finite non-empty set of \emph{states}, $S_0 \subseteq S$ is the set of \emph{initial states}, $F \subseteq S$ is the set of \emph{accepting states} and $\Delta: S \times \Sigma \times S$ is a \emph{transition relation}. When suitable we will use the arrow notation for the transitions, where $s \xrightarrow{a} s'$ iff $(s, a, s') \in \Delta$.
137 A \emph{deterministic B\"uchi automaton} is a specialisation, where the \emph{transition relation} $\Delta$ is a \emph{transition function} $\delta: S \times \Sigma \to S$ and the set $S_0$ of \emph{initial states} contains only a single state $s_0$.
139 Within this text \emph{automaton} will refer to the non-deterministic B\"uchi automaton, unless otherwise noted.
140 \end{def:buechi automata}
142 \begin{def:automata runs}
143 Let $\A = (\Sigma, S, S_0, \Delta, F)$ be an automaton, a run $\rho$ of $\A$ on an infinite word $w = (a_0,a_1,...)$ over alphabet $\Sigma$ is a sequence $\rho = (s_0,s_1,...)$, where $s_0 \in S_0$ and $(s_i, a_i, s_{i+1}) \in \Delta$, for all $i \geq 0$. Again we may view the run sequence as a function $\rho : \N \to S$, where $\rho(i) = s_i$ denotes the state at the $i^{th}$ sequence position.
144 \end{def:automata runs}
146 \begin{def:automata acceptance}
147 Let $\A = (\Sigma, S, S_0, \Delta, F)$ be an automaton and let $\rho$ be a run of $\A$, we define $inf(\rho) = \{s \in S \mid \exists^\omega{n \in \N}: \rho(n) = s\}$, where $\exists^\omega$ denotes the existential quantifier for infinitely many occurances, i.e., $s$ occurs infinitely often in $\rho$.
149 The run $\rho$ is \emph{accepting} iff $inf(\rho) \cap F \neq \emptyset$, i.e., there exists an \emph{accepting state} which occurs infinitely often in the run $\rho$. The automaton $\A$ \emph{accepts} an input word $w$, iff there exists a run $\rho$ of $\A$ on $w$, such that $\rho$ is \emph{accepting}.
151 The language $L_\omega(\A)$ recognised by automaton $\A$ is the set of all infinite words accepted by $\A$. A language $L$ is \emph{B\"uchi-recognisable} iff there is an automaton $\A$ with $L = L_\omega(\A)$.
152 \end{def:automata acceptance}
154 \subsection{Generalised B\"uchi automata}
155 \begin{def:general automata}
156 A \emph{generalised B\"uchi automaton} is a tuple $\A = (\Sigma, S, S_0, \Delta, \{F_i\}_{i < k})$ for $i, k \in \N$, where the \emph{acceppting states} $F_i$ are composed within a finite set with $F_i \subseteq S$.
157 \end{def:general automata}
159 \begin{def:general acceptance}
160 The acceptance condition is adjusted accordingly. A run $\rho$ of $\A$ is \emph{accepting} iff $\forall{i < k}: inf(\rho) \cap F_i \neq \emptyset$.
161 \end{def:general acceptance}
163 \begin{prop:general equiv}
164 Let $\A = (\Sigma, S, S_0, \Delta, \{F_i\}_{i < k})$ be a \emph{generalised automaton} and let $\A_i = (\Sigma, S, S_0, \Delta, F_i)$ be \emph{non-deterministic automata}, then following equivalance condition holds:
165 \[L_\omega(\A) = \bigcap_{i < k} L_\omega(\A_i)\]
166 \end{prop:general equiv}
167 \noindent Intuitively follows the equivalance of the language recognition abilities of general and non-deterministic B\"uchi automata.
169 \section{Linear temporal logic}
171 Let $\Prop$ be the countable set of \emph{atomic propositions}. The \emph{alphabet} of the language $L_{LTL}(\Prop)$ is $\Prop \cup \{\neg, \lor, \X, \U\}$. We define the $L_{LTL}(\Prop)$-\emph{formulae} $\varphi$ using following productions:
172 \[\varphi ::= p \in \Prop \,|\, \neg \varphi \,|\, \varphi \lor \varphi \,|\, \X \varphi \,|\, \varphi \U \varphi\]
174 \subsection{Interpretation}
175 The intuition should go as follows: $\neg$ and $\lor$ correspond to the Boolean \emph{negation} and \emph{disjunction}, the unary temporal operator $\X$ reads as \emph{next} and the binary temporal operator $\U$ reads as \emph{until}.
177 LTL is interpreted over \emph{computation paths}, where a computation corrensponds to a model over a \emph{Kripke-frame} constructed by the order of natural numbers.
179 \subsection{Semantics}
181 An LTL-\emph{frame} is a tuple $\F = (S, R)$, where $S = \{s_i \mid i \in \N\}$ is the set of states and $R = \{(s_i, s_{i+1}) \mid i \in \N\}$ the set of accessibility relations. Hence $S$ is an isomorphism of $\N$ and $R$ an isomorphism of the strict linear order $(\N, <)$, which corresponds to the linear progression of discrete time.
185 An LTL-\emph{model} is a tuple $\M = (\F, V)$, where $\F$ is a \emph{frame} and $V: S \to 2^\Prop$ a \emph{valuation function}. Intuitively we say $p \in \Prop$ is \emph{true} at time instant $i$ iff $p \in V(i)$.
186 %A \emph{model} is a function $\M: \N \to 2^\Prop$ over \emph{frame} $\F$. The frame constitutes a linear order over $\N$, which corresponds to the linear progression of time from the \emph{present/past} into the \emph{future}. Therefore $\M(i)$ assigns a set of \emph{positive atomic propositions} to each state of time instant $i$. Intuitively we say $p \in \Prop$ is \emph{true} at time instant $i$ iff $p \in \M(i)$.
189 \begin{def:satisfiability}
190 A model $\M = (\F, V)$ \emph{satisfies} a formula $\varphi$ at time instant $i$ is denoted by $\M,i \models \varphi$. Satisfiability of a formula $\varphi$ is defined inductively over the structure of $\varphi$:
192 \item $\M,i \models p$ for $p \in \Prop \iff p \in V(i)$
193 \item $\M,i \models \neg \varphi \iff$ not $\M,i \models \varphi$
194 \item $\M,i \models \varphi \lor \psi \iff \M,i \models \varphi$ or $\M,i \models \psi$
195 \item $\M,i \models \X \varphi \iff \M,i+1 \models \varphi$
196 \item $\M,i \models \varphi \U \psi \iff \exists{k \geq i}: \M,k \models \psi$ and $\forall{i \leq j < k}: \M,j \models\varphi$
199 \end{def:satisfiability}
201 \begin{def:vocabulary}
202 Let $\varphi$ be an LTL-formula over atomic propositions $\Prop$, we define the \emph{vocabulary} $Voc(\varphi)$ of $\varphi$ inductively:
205 \item $Voc(p) = \{p\}$ for $p \in \Prop$
206 \item $Voc(\neg \varphi) = Voc(\varphi)$
207 \item $Voc(\varphi \lor \psi) = Voc(\varphi) \cup Voc(\psi)$
208 \item $Voc(\X \varphi) = Voc(\varphi)$
209 \item $Voc(\varphi \U \psi) = Voc(\varphi) \cup Voc(\psi)$
213 \noindent Let $\M = (\F, V)$ be a model and $\varphi$ an LTL-formula, we define model $\M_{Voc(\varphi)} = (\F, V_{Voc(\varphi)})$ with:
214 \[\forall{i \in \N}: V_{Voc(\varphi)}(i) = V(i) \cap Voc(\varphi)\]
215 Henceforth, we will abbreviate $\M_{Voc(\varphi)}$ and $V_{Voc(\varphi)}$ with $\M_\varphi$ and $V_\varphi$ accordingly.
216 %\noindent Let $\M$ be a model and $\varphi$ an LTL-formula, we define model $\M_{Voc(\varphi)}$:
217 %\[\forall{i \in \N}: \M_{Voc(\varphi)} = \M(i) \cap Voc(\varphi)\]
220 \begin{prop:vocabulary sat}
221 Let $\M$ be a model and $\varphi$ an LTL-formula, then following holds:
222 \[\forall{i \in \N}: \M,i \models \varphi \iff \M_\varphi,i \models \varphi\]
223 \end{prop:vocabulary sat}
225 \subsection{Derived connectives}
226 For a more convenient description of system specifications, we present some derived symbols to be used in LTL-formulae. At first, we introduce the notion of \emph{truth} and \emph{falsity} using constants $\top$ and $\bot$. Then we expand our set of connectives with the Boolean \emph{and}, \emph{implication} and \emph{equivalence}. And at last we derive the commonly used modal operators \emph{eventually} and \emph{henceforth}.
228 Let $\varphi$ and $\psi$ be $L_{LTL}(\Prop)$-formulae:
231 \item $\top \equiv p \lor \neg p$ for $p \in \Prop$
232 \item $\bot \equiv \neg \top$
233 \item $\varphi \land \psi \equiv \neg (\neg \varphi \lor \neg \psi)$
234 \item $\varphi \rightarrow \psi \equiv \neg \varphi \lor \psi$
235 \item $\varphi \leftrightarrow \psi \equiv (\varphi \rightarrow \psi) \land (\psi \rightarrow \varphi)$
236 \item $\Diamond \varphi \equiv \top \U \varphi$
237 \item $\Box \varphi \equiv \neg \Diamond \neg \varphi$
240 \noindent From the derivations for operators $\Diamond$, \emph{read diamond}, and $\Box$, \emph{read box}, it follows:
243 \item $\M,i \models \Diamond \varphi \iff \exists{k \geq i}: \M,k \models \varphi$
244 \item $\M,i \models \Box \varphi \iff \forall{k \geq i}: \M,k \models \varphi$
248 \noindent With the additional derived connectives we get the following $L_{LTL}(\Prop)$-formulae productions:
249 \[\varphi ::= p \in \Prop \,|\, \neg \varphi \,|\, \varphi \lor \varphi \,|\, \varphi \land \varphi \,|\, \X \varphi \,|\, \varphi \U \varphi \,|\, \varphi \rightarrow \varphi \,|\, \varphi \leftrightarrow \varphi \,|\, \Diamond \varphi \,|\, \Box \varphi\]
251 \section{Automata construction}
252 Before applying the automata-theoretic verification methods, we need to construct the automaton for a given specification formula $\varphi$ and for the program $P$ in test.
254 \subsection{Specification automata}
255 For the construction of an automaton $\A_\varphi$ for an LTL-formula $\varphi$, we treat the model $\M = (\F, V)$ for an LTL-formula $\varphi$ as an infinite word over the finite alphabet $2^{Voc(\varphi)}$.
257 \begin{def:rep function}
258 We define the \emph{representation function} $rep: \M \to 2^\Prop$, which returns an infinite word representing the model $\M_\varphi = (\F, V_\varphi)$ over the ordered image $V_\varphi^\rightarrow(\N)$ of its validation function, i.e., $rep(\M_\varphi) = (V_\varphi(0), V_\varphi(1), ...)$. Additionaly, we provide the \emph{inverted representation function} $rep^{-1}: 2^\Prop \to \M$, which compiles an infinite word to the corresponding model, i.e., $rep^{-1}(V_\varphi^\rightarrow(\N)) = \M_\varphi$.
259 \[Mod(\varphi) = \{rep(\M_\varphi) \mid \M_\varphi = (\F, V_\varphi) \land \M_\varphi,0 \models \varphi\}\]
260 $Mod(\varphi)$ is the set of all infinite words, which represent models for $\varphi$.
261 \end{def:rep function}
263 \begin{def:fs closure}
264 Let $\varphi$ be an LTL-formula, then the \emph{Fischer-Ladner closure} $CL(\varphi)$ of $\varphi$ is the smallest set of formulae such that following holds:
265 %\begin{multicols}{2}
267 \item $\varphi \in CL(\varphi)$
268 \item $\neg \psi \in CL(\varphi) \implies \psi \in CL(\varphi)$
269 \item $\psi \in CL(\varphi) \implies \neg \psi \in CL(\varphi)$
270 \item $\psi \lor \chi \in CL(\varphi) \implies \psi, \chi \in CL(\varphi)$
271 \item $\X \psi \in CL(\varphi) \implies \psi \in CL(\varphi)$
272 \item $\psi \U \chi \in CL(\varphi) \implies \psi, \chi, \X(\psi \U \chi) \in CL(\varphi)$
277 \noindent Let $CL(\varphi)$ be the closure of formula $\varphi$, we define a subset with the \emph{until}-formulae of the closure $\mathbb{U}_\varphi \subseteq CL(\varphi)$ where:
278 \[\mathbb{U}_\varphi = \{\psi \U \chi \in CL(\varphi)\} \text{ and } \mathbb{U}_{\varphi_i} \text{ denotes the $i^{th}$ element of } \mathbb{U_\varphi}\]
281 Let $\varphi$ be a formula and $CL(\varphi)$ its closure. $A \subseteq CL(\varphi)$ is an \emph{atom} if following holds:
283 \item $\forall{\psi \in CL(\varphi)}: \psi \in A \iff \neg \psi \notin A$
284 \item $\forall{\psi \lor \chi \in CL(\varphi)}: \psi \lor \chi \in A \iff \psi \in A$ or $\chi \in A$
285 \item $\forall{\psi \U \chi \in CL(\varphi)}: \psi \U \chi \in A \iff \chi \in A$ or $\psi, \X(\psi \U \chi) \in A$
287 We define the set of all atoms of formula $\varphi$ with $\mathbb{AT}_\varphi = \{A \subseteq CL({\varphi}) \mid A \text{ is an atom}\}$.
290 \noindent Now that we have the required ingredients, we begin with the construction of automaton $\A_\varphi$ for formula $\varphi$. Let $\A_\varphi = (\Sigma, S, S_0, \Delta, \{F_i\}_{i < k})$ with:
292 \item $\Sigma = 2^{Voc(\varphi)}$
293 \item $S = \mathbb{AT_\varphi}$
294 \item $S_0 = \{A \in \mathbb{AT_\varphi} \mid \varphi \in A\}$
295 %\item $(A, P, B) \in \Delta$ for $A, B \in \mathbb{AT_\varphi}$ and $P = A \cap Voc(\varphi) \iff (\X \psi \in A \iff \psi \in B)$
296 \item $\Delta = \{(A, P, B) \mid A, B \in \mathbb{AT_\varphi}, P = A \cap Voc(\varphi), \X \psi \in A \iff \psi \in B\}$
297 %\item $\forall{i \in \N, i < k = |\mathbb{U}_{CL(\varphi)}|}: F_i = \{A \in \mathbb{AT}_\varphi \mid \psi \U \chi \notin A$ or $\chi \in A\}$
298 \item $F_i = \{A \in \mathbb{AT}_\varphi \mid \psi \U \chi = \mathbb{U}_{\varphi_i}, \psi \U \chi \notin A$ or $\chi \in A\}$ and therefore $k = |\mathbb{U}_{\varphi}|$
299 %Let $A, B \in \mathbb{AT}$ and $P \subseteq Voc(\varphi)$. Then $(A, P, B) \in \Delta$ iff the following holds:
300 %$P = A \cap Voc(\varphi)$ and For all $\X \psi \in CL(\varphi): \X \psi \in A$ iff $\psi \in B$.
303 \begin{thm:model language}
304 \label{thm:model language}
305 Let $\M_\varphi = (\F, V_\varphi)$ be a model and $rep(\M_\varphi)$ its infinite representation word, then following holds:
306 \[rep(\M_\varphi) \in L_\omega(\A_\varphi) \iff \M_\varphi,0 \models \varphi\]
307 \end{thm:model language}
310 For the eloberate proof, consult \cite{ref:ltl&büchi}.
312 \begin{cor:mod=model language}
313 \label{cor:mod=model language}
314 From Theorem \ref{thm:model language} follows $Mod(\varphi) = L_\omega(\A_\varphi)$.
315 \end{cor:mod=model language}
317 \subsection{Program automata}
318 In the next step, we model a given program $P$ as automaton $\A_P$. A program is a structure $P = (S_P, s_0, R, V)$, where $S$ is the set of possible states of the program, $s_0$ the initial state, $R : S \times \Prop \times S$ the transition relation and $V : S \to 2^\Prop$ a valuation function. A \emph{computation} of $P$ is a run $\rho = (V(s_0), V(s_1), ...)$.
320 We construct automaton $\A_P = (\Sigma, S, S_0, \Delta, F)$, with:
323 \item $\Sigma = 2^\Prop$
325 \item $S_0 = \{s_0\}$
328 \item $\Delta = \{(s, V(s), s') \mid \exists{a \in \Prop}: (s, a, s') \in R\}$
330 In practical verification of programs, the specification covers only the properties of a system, which are vital to the program's correctness, where our program description contains all details of all possible execution paths. Let $\varphi$ be the specification formula, we can reduce the state exploration to the vocabulary of $\varphi$ by the reduction of the transition relation to $\Delta = \{(s, A, s') \mid \exists{a \in \Prop}: (s, a, s') \in R \land A = V(s) \cap Voc(\varphi)\}$.
332 \begin{prop:computation set=language}
333 \label{prop:computation set=language}
334 Let $\A_P = (\Sigma, S, S_0, \Delta, F)$, for $F = S$ it follows that each run of $\A_P$ is accepting, therefore is $L_\omega(\A_P)$ the set of all computations of $P$.
335 \[L_\omega(\A_P) = \{\rho \mid \rho \text{ is a run of } \A_P\}\]
336 \end{prop:computation set=language}
338 We can view each run of $\A_P$, i.e., each computation of $P$, as a representation of model $\M_\rho = (\F, V)$, where $\F$ is a frame and $V$ the program's valuation function. In analogy to the specification, we define:
339 \[Mod(P) = \{\rho \mid \rho \text{ is a computation of } P\}\]
340 \begin{cor:mod=program language}
341 \label{cor:mod=program language}
342 From Theorem \ref{thm:model language} and Proposition \ref{prop:computation set=language} follows $Mod(P) = L_\omega(\A_P)$.
343 \end{cor:mod=program language}
345 \section{Model checking}
346 For effective automata-theoretic verification of reactive programs, we have modelled the program as a non-deterministic B\"uchi automaton $\A_P$ and the specification formula $\varphi$ as automaton $\A_\varphi$.
348 Given a program $P$ and specification $\varphi$, the verification problem is the following: \emph{does every run of $P$ satisfy $\varphi$?} To show this we use the previously introduced automata constructions and reduce the problem to $L_\omega(\A_P) \subseteq L_\omega(\A_\varphi)$, i.e., all runs accepted by $\A_P$ are also accepted by $\A_\varphi$. By this problem definition, we clearly have to explore the whole state space of $\A_\varphi$ for each run of $\A_P$. This prevents efficient on-demand constructions. Therefore we rephrase the problem with the contrapositive definition $L_\omega(\A_P) \cap \overline{L_\omega(\A_\varphi)} = \emptyset$, where $\overline{L_\omega(\A_\varphi)} = \Sigma^\omega - L_\omega(\A_\varphi) = L_\omega(\A_{\neg \varphi})$ \cite{ref:alternating verification}.
350 In conclusion, the essence of model checking lies within the test for emptyness of the intersection between the recognised language of the program automaton and the recognised language of the automaton for its negated specification:
351 \[L_\omega(\A_P) \cap L_\omega(\A_{\neg \varphi}) = \emptyset\]
353 \begin{thm:model checking}
354 \label{thm:model checking}
355 Let $P$ be a finite-state program and $\A_P$ its automaton, let $\varphi$ be an LTL-formula and $\A_\varphi$ its automaton. P satisfies $\varphi$ iff $L_\omega(\A_P) \cap L_\omega(\A_{\neg \varphi}) = \emptyset$.
356 \end{thm:model checking}
358 From Corollary \ref{cor:mod=model language} and \ref{cor:mod=program language} follows:
359 \[L_\omega(\A_P) \cap L_\omega(\A_{\neg \varphi}) = \emptyset \iff Mod(P) \cap Mod(\neg \varphi) = \emptyset\]
361 \subsection{Complexity}
362 Let the size $|P|$ of a program $P = (S, s_0, R, V)$ be proportional to the sum of its structural components, i.e., $|P| = |S| + |R|$. The size $|\varphi|$ is the length of the formula string. The asymptotical complexity of the presented automata-theoretic verification method is in time $O(|P| \cdot 2^{O(|\varphi|)})$ \cite{ref:concurrent checking}.
364 The size of $\varphi$ is usually short \cite{ref:concurrent checking}, so the exponential growth by it is reasonable. Generally, the number of states is at least exponential in the size of its description by means of a programming language. This concludes, that despite that the upper bound is polynomial in the size of the program, in practice, we are facing exponential growth in complexity \cite{ref:handbook}.
366 \section{On-the-fly methods}
367 The automata-theoretic approach on verification in Theorem \ref{thm:model checking} requires a fully constructed automaton for the specification, when applying the graph-theoretic emptyness test.
369 A more space-efficient strategy is the on-the-fly construction of the automaton during a depth-first search, short DFS. The DFS explores the product states of both automata incrementally, testing for cycles in each iteration. If the program does not satisfy a formula, an accepting cycle will occur and lead to termination of the search. In the case of a valid program, i.e., the program does meet the specification, no cycles will occur. In the latter case, such a strategy would inevitably explore the whole state space of the automata.
371 \begin{def:positive formulae}
372 Let $\Prop$ be a set of atomic propositions, let $\overline{\Prop} = \{\neg p \mid p \in \Prop\}$ and let us extend the LTL-syntax with the binary operator $\V$ with $\varphi \V \psi \equiv \neg(\neg \varphi \U \psi)$. We define the set of LTL-formulae in \emph{positive form}:
373 \[\Phi^+ = \Prop \cup \overline{\Prop} \cup \{\top, \bot\} \cup \{\varphi \lor \psi, \varphi \land \psi, \X\varphi, \varphi \U \psi, \varphi \V \psi \mid \varphi, \psi \in \Phi^+\} \]
374 \end{def:positive formulae}
377 Let $\Phi$ be a set of LTL-formulae, we define:
378 \[next(\Phi) = \{ \X\varphi \mid \X\varphi \in \Phi\} \text{ and } snext(\Phi) = \{ \varphi \mid \X\varphi \in \Phi\}\]
382 Let $\Phi^+$ be the set of LTL-formulae in positive form and let $Q = \Prop \cup \overline{\Prop} \cup next(\Phi^+)$, we define function $\dnf: \Phi^+ \to Q$ inductively:
384 &\dnf(\top) &= &\, \{\emptyset\}\\
385 &\dnf(\bot) &= &\, \emptyset\\
386 &\dnf(x) &= &\, \{\{x\}\}, \text{ for } x = p, \neg p, \X\varphi\\
387 &\dnf(\varphi \lor \psi) &= &\, \dnf(\varphi) \cup \dnf(\psi)\\
388 &\dnf(\varphi \land \psi) &= &\, \{C \cup D \mid C \in \dnf(\varphi), D \in \dnf(\psi), C \cup D \text{ is consistent}\}\\
389 &\dnf(\varphi \U \psi) &= &\, \dnf(\varphi \land \X(\varphi \U \psi)) \cup \dnf(\psi)\\
390 &\dnf(\varphi \V \psi) &= &\, \dnf(\varphi \land \psi) \cup \dnf(\psi \land \X(\varphi \V \psi))\\
395 Let $\Phi^+$ be the set of formulae in positive form, following holds:
396 \[\forall{\varphi \in \Phi^+}: \varphi \iff \bigvee_{D \in \dnf(\varphi)} \bigwedge D\]
399 \begin{thebibliography}{99}
400 \bibitem{ref:ltl&büchi}
401 \uppercase{M{\footnotesize adhavan} M{\footnotesize ukund}.}
402 {\em Linear-Time Temporal Logic and B\"uchi Automata}.
403 Winter School on Logic and Computer Science, Indian Statistical Institute, Calcutta, 1997.
405 \bibitem{ref:alternating verification}
406 \uppercase{M{\footnotesize oshe} Y. V{\footnotesize ardi}.}
407 {\em Alternating Automata and Program Verification}.
408 Computer Science Today, Volume 1000 of Lecture Notes in Computer Science, Springer-Verlag, Berlin, 1995.
410 \bibitem{ref:concurrent checking}
411 \uppercase{O{\footnotesize rna} L{\footnotesize ichtenstein and} A{\footnotesize mir} P{\footnotesize nueli}.}
412 {\em Checking that finite state concurrent programs satisfy their linear specification}.
413 Proceeding 12th ACM Symposium on Principles of Programming Languages, New York, 1985.
415 \bibitem{ref:infpaths}
416 \uppercase{P{\footnotesize ierre} W{\footnotesize olper},
417 M{\footnotesize oshe} Y. V{\footnotesize ardi and}
418 A. P{\footnotesize rasad} S{\footnotesize istla}.}
419 {\em Reasoning about Infinite Computation Paths}.
420 In Proceedings of the 24th IEEE FOCS, 1983.
422 \bibitem{ref:handbook}
423 \uppercase{P{\footnotesize atrick} B{\footnotesize lackburn},
424 F{\footnotesize rank} W{\footnotesize olter and} J{\footnotesize ohan van} B{\footnotesize enthem}.}
425 {\em Handbook of Modal Logic (Studies in Logic and Practical Reasoning)}.
426 3rd Edition, Elsevier, Amsterdam, 2007.
427 \end{thebibliography}