1,868 research outputs found
An Efficient Normalisation Procedure for Linear Temporal Logic and Very Weak Alternating Automata
In the mid 80s, Lichtenstein, Pnueli, and Zuck proved a classical theorem
stating that every formula of Past LTL (the extension of LTL with past
operators) is equivalent to a formula of the form , where
and contain only past operators. Some years later, Chang,
Manna, and Pnueli built on this result to derive a similar normal form for LTL.
Both normalisation procedures have a non-elementary worst-case blow-up, and
follow an involved path from formulas to counter-free automata to star-free
regular expressions and back to formulas. We improve on both points. We present
a direct and purely syntactic normalisation procedure for LTL yielding a normal
form, comparable to the one by Chang, Manna, and Pnueli, that has only a single
exponential blow-up. As an application, we derive a simple algorithm to
translate LTL into deterministic Rabin automata. The algorithm normalises the
formula, translates it into a special very weak alternating automaton, and
applies a simple determinisation procedure, valid only for these special
automata.Comment: This is the extended version of the referenced conference paper and
contains an appendix with additional materia
Efficient Normalization of Linear Temporal Logic
In the mid 80s, Lichtenstein, Pnueli, and Zuck proved a classical theorem
stating that every formula of Past LTL (the extension of LTL with past
operators) is equivalent to a formula of the form , where
and contain only past operators. Some years later, Chang,
Manna, and Pnueli built on this result to derive a similar normal form for LTL.
Both normalization procedures have a non-elementary worst-case blow-up, and
follow an involved path from formulas to counter-free automata to star-free
regular expressions and back to formulas. We improve on both points. We present
direct and purely syntactic normalization procedures for LTL, yielding a normal
form very similar to the one by Chang, Manna, and Pnueli, that exhibit only a
single exponential blow-up. As an application, we derive a simple algorithm to
translate LTL into deterministic Rabin automata. The algorithm normalizes the
formula, translates it into a special very weak alternating automaton, and
applies a simple determinization procedure, valid only for these special
automata.Comment: Submitted to J. ACM. arXiv admin note: text overlap with
arXiv:2304.08872, arXiv:2005.0047
A Simple Rewrite System for the Normalization of Linear Temporal Logic
In the mid 80s, Lichtenstein, Pnueli, and Zuck showed that every formula of
Past LTL (the extension of Linear Temporal Logic with past operators) is
equivalent to a conjunction of formulas of the form , where and contain
only past operators. Some years later, Chang, Manna, and Pnueli derived a
similar normal form for LTL. Both normalization procedures have a
non-elementary worst-case blow-up, and follow an involved path from formulas to
counter-free automata to star-free regular expressions and back to formulas. In
2020, Sickert and Esparza presented a direct and purely syntactic normalization
procedure for LTL yielding a normal form similar to the one by Chang, Manna,
and Pnueli, with a single exponential blow-up, and applied it to the problem of
constructing a succinct deterministic -automaton for a given formula.
However, their procedure had exponential time complexity in the best case. In
particular, it does not perform better for formulas that are almost in normal
form. In this paper we present an alternative normalization procedure based on
a simple set of rewrite rules
UNITY and Büchi automata
UNITY is a model for concurrent specifications with a complete logic for proving progress properties of the form `` leads to ''. UNITY is generalized to U-specifications by giving more freedom to specify the steps that are to be taken infinitely often. In particular, these steps can correspond to non-total relations. The generalization keeps the logic sound and complete. The paper exploits the generalization in two ways. Firstly, the logic remains sound when the specification is extended with hypotheses of the form `` leads to ''. As the paper shows, this can make the logic incomplete. The generalization is used to show that the logic remains complete, if the added hypotheses `` leads to '' satisfy `` unless ''. The main result extends the applicability and completeness of UNITY logic to proofs that a given concurrent program satisfies any given formula of LTL, linear temporal logic, without the next-operator which is omitted because it is sensitive to stuttering. For this purpose, the program, written as a UNITY program, is extended with a number of boolean variables. The proof method relies on implementing the LTL formula, i.e., restricting the specification in such a way that only those runs remain that satisfy the formula. This result is a variation of the classical construction of a B\"uchi automaton for a given LTL formula that accepts precisely those runs that satisfy the formula
Is there a best Büchi automaton for explicit model checking?
LTL to Büchi automata (BA) translators are traditionally optimized to produce automata with a small number of states or a small number of non-deterministic states. In this paper, we search for properties of Büchi automata that really influence the performance of explicit model checkers. We do that by manual analysis of several automata and by experiments with common LTL-to-BA translators and realistic verification tasks. As a result of these experiences, we gain a better insight into the characteristics of automata that work well with Spin.Překladače LTL na Büchiho automaty jsou obvykle optimalizovány tak, aby produkovaly automaty s co nejmenším počtem stavů, či s co nejmenším počtem nedeterministických stavů. V této publikaci hledáme vlastnosti Büchiho automatů, které skutečně ovlivňují výkon nástrojů pro explicitní metodu ověřování modelu (model checking). A to pomocí manuální analýzy několika automatů a experimenty s běžnými překladače LTL na automaty a realistickými verifikačními úlohami. Výsledkem těchto experimentů je lepší porozumění charakteristik automatů, které jsou dobré pro model checker Spin
Truly On-The-Fly LTL Model Checking
We propose a novel algorithm for automata-based LTL model checking that
interleaves the construction of the generalized B\"{u}chi automaton for the
negation of the formula and the emptiness check. Our algorithm first converts
the LTL formula into a linear weak alternating automaton; configurations of the
alternating automaton correspond to the locations of a generalized B\"{u}chi
automaton, and a variant of Tarjan's algorithm is used to decide the existence
of an accepting run of the product of the transition system and the automaton.
Because we avoid an explicit construction of the B\"{u}chi automaton, our
approach can yield significant improvements in runtime and memory, for large
LTL formulas. The algorithm has been implemented within the SPIN model checker,
and we present experimental results for some benchmark examples
A Learning Based Approach to Control Synthesis of Markov Decision Processes for Linear Temporal Logic Specifications
We propose to synthesize a control policy for a Markov decision process (MDP)
such that the resulting traces of the MDP satisfy a linear temporal logic (LTL)
property. We construct a product MDP that incorporates a deterministic Rabin
automaton generated from the desired LTL property. The reward function of the
product MDP is defined from the acceptance condition of the Rabin automaton.
This construction allows us to apply techniques from learning theory to the
problem of synthesis for LTL specifications even when the transition
probabilities are not known a priori. We prove that our method is guaranteed to
find a controller that satisfies the LTL property with probability one if such
a policy exists, and we suggest empirically with a case study in traffic
control that our method produces reasonable control strategies even when the
LTL property cannot be satisfied with probability one
"More Deterministic" vs. "Smaller" Buechi Automata for Efficient LTL Model Checking
The standard technique for LTL model checking (M\models\neg\vi) consists on translating the negation of the LTL specification, \vi, into a B\"uchi automaton A_\vi, and then on checking if the product M \times A_\vi has an empty language. The efforts to maximize the efficiency of this process have so far concentrated on developing translation algorithms producing B\"uchi automata which are ``{\em as small as possible}'', under the implicit conjecture that this fact should make the final product smaller. In this paper we build on a different conjecture and present an alternative approach in which we generate instead B\"uchi automata which are ``{\em as deterministic as possible}'', in the sense that we try to reduce as much as we are able to the presence of non-deterministic decision states in A_\vi. We motivate our choice and present some empirical tests to support this approach
Verifying Temporal Regular Properties of Abstractions of Term Rewriting Systems
The tree automaton completion is an algorithm used for proving safety
properties of systems that can be modeled by a term rewriting system. This
representation and verification technique works well for proving properties of
infinite systems like cryptographic protocols or more recently on Java Bytecode
programs. This algorithm computes a tree automaton which represents a (regular)
over approximation of the set of reachable terms by rewriting initial terms.
This approach is limited by the lack of information about rewriting relation
between terms. Actually, terms in relation by rewriting are in the same
equivalence class: there are recognized by the same state in the tree
automaton.
Our objective is to produce an automaton embedding an abstraction of the
rewriting relation sufficient to prove temporal properties of the term
rewriting system.
We propose to extend the algorithm to produce an automaton having more
equivalence classes to distinguish a term or a subterm from its successors
w.r.t. rewriting. While ground transitions are used to recognize equivalence
classes of terms, epsilon-transitions represent the rewriting relation between
terms. From the completed automaton, it is possible to automatically build a
Kripke structure abstracting the rewriting sequence. States of the Kripke
structure are states of the tree automaton and the transition relation is given
by the set of epsilon-transitions. States of the Kripke structure are labelled
by the set of terms recognized using ground transitions. On this Kripke
structure, we define the Regular Linear Temporal Logic (R-LTL) for expressing
properties. Such properties can then be checked using standard model checking
algorithms. The only difference between LTL and R-LTL is that predicates are
replaced by regular sets of acceptable terms
How Deterministic are Good-For-Games Automata?
In GFG automata, it is possible to resolve nondeterminism in a way that only
depends on the past and still accepts all the words in the language. The
motivation for GFG automata comes from their adequacy for games and synthesis,
wherein general nondeterminism is inappropriate. We continue the ongoing effort
of studying the power of nondeterminism in GFG automata. Initial indications
have hinted that every GFG automaton embodies a deterministic one. Today we
know that this is not the case, and in fact GFG automata may be exponentially
more succinct than deterministic ones.
We focus on the typeness question, namely the question of whether a GFG
automaton with a certain acceptance condition has an equivalent GFG automaton
with a weaker acceptance condition on the same structure. Beyond the
theoretical interest in studying typeness, its existence implies efficient
translations among different acceptance conditions. This practical issue is of
special interest in the context of games, where the Buchi and co-Buchi
conditions admit memoryless strategies for both players. Typeness is known to
hold for deterministic automata and not to hold for general nondeterministic
automata.
We show that GFG automata enjoy the benefits of typeness, similarly to the
case of deterministic automata. In particular, when Rabin or Streett GFG
automata have equivalent Buchi or co-Buchi GFG automata, respectively, then
such equivalent automata can be defined on a substructure of the original
automata. Using our typeness results, we further study the place of GFG
automata in between deterministic and nondeterministic ones. Specifically,
considering automata complementation, we show that GFG automata lean toward
nondeterministic ones, admitting an exponential state blow-up in the
complementation of a Streett automaton into a Rabin automaton, as opposed to
the constant blow-up in the deterministic case
- …