605 research outputs found
Bounded Reachability for Temporal Logic over Constraint Systems
We present CLTLB(D), an extension of PLTLB (PLTL with both past and future
operators) augmented with atomic formulae built over a constraint system D.
Even for decidable constraint systems, satisfiability and Model Checking
problem of such logic can be undecidable. We introduce suitable restrictions
and assumptions that are shown to make the satisfiability problem for the
extended logic decidable. Moreover for a large class of constraint systems we
propose an encoding that realize an effective decision procedure for the
Bounded Reachability problem
Clafer: Lightweight Modeling of Structure, Behaviour, and Variability
Embedded software is growing fast in size and complexity, leading to intimate
mixture of complex architectures and complex control. Consequently, software
specification requires modeling both structures and behaviour of systems.
Unfortunately, existing languages do not integrate these aspects well, usually
prioritizing one of them. It is common to develop a separate language for each
of these facets. In this paper, we contribute Clafer: a small language that
attempts to tackle this challenge. It combines rich structural modeling with
state of the art behavioural formalisms. We are not aware of any other modeling
language that seamlessly combines these facets common to system and software
modeling. We show how Clafer, in a single unified syntax and semantics, allows
capturing feature models (variability), component models, discrete control
models (automata) and variability encompassing all these aspects. The language
is built on top of first order logic with quantifiers over basic entities (for
modeling structures) combined with linear temporal logic (for modeling
behaviour). On top of this semantic foundation we build a simple but expressive
syntax, enriched with carefully selected syntactic expansions that cover
hierarchical modeling, associations, automata, scenarios, and Dwyer's property
patterns. We evaluate Clafer using a power window case study, and comparing it
against other notations that substantially overlap with its scope (SysML, AADL,
Temporal OCL and Live Sequence Charts), discussing benefits and perils of using
a single notation for the purpose
Logical and deep learning methods for temporal reasoning
In this thesis, we study logical and deep learning methods for the temporal reasoning of reactive systems. In Part I, we determine decidability borders for the satisfiability and realizability problem of temporal hyperproperties. Temporal hyperproperties relate multiple computation traces to each other and are expressed in a temporal hyperlogic. In particular, we identify decidable fragments of the highly expressive hyperlogics HyperQPTL and HyperCTL*. As an application, we elaborate on an enforcement mechanism for temporal hyperproperties. We study explicit enforcement algorithms for specifications given as formulas in universally quantified HyperLTL. In Part II, we train a (deep) neural network on the trace generation and realizability problem of linear-time temporal logic (LTL). We consider a method to generate large amounts of additional training data from practical specification patterns. The training data is generated with classical solvers, which provide one of many possible solutions to each formula. We demonstrate that it is sufficient to train on those particular solutions such that the neural network generalizes to the semantics of the logic. The neural network can predict solutions even for formulas from benchmarks from the literature on which the classical solver timed out. Additionally, we show that it solves a significant portion of problems from the annual synthesis competition (SYNTCOMP) and even out-of-distribution examples from a recent case study.Diese Arbeit befasst sich mit logischen Methoden und mehrschichtigen Lernmethoden fĂŒr das zeitabhĂ€ngige Argumentieren ĂŒber reaktive Systeme. In Teil I werden die Grenzen der Entscheidbarkeit des ErfĂŒllbarkeits- und des Realisierbarkeitsproblem von temporalen Hypereigenschaften bestimmt. Temporale Hypereigenschaften setzen mehrere Berechnungsspuren zueinander in Beziehung und werden in einer temporalen Hyperlogik ausgedrĂŒckt. Insbesondere werden entscheidbare Fragmente der hochexpressiven Hyperlogiken HyperQPTL und HyperCTL* identifiziert. Als Anwendung wird ein Enforcement-Mechanismus fĂŒr temporale Hypereigenschaften erarbeitet. Explizite Enforcement-Algorithmen fĂŒr Spezifikationen, die als Formeln in universell quantifiziertem HyperLTL angegeben werden, werden untersucht. In Teil II wird ein (mehrschichtiges) neuronales Netz auf den Problemen der Spurgenerierung und Realisierbarkeit von Linear-zeit Temporallogik (LTL) trainiert. Es wird eine Methode betrachtet, um aus praktischen Spezifikationsmustern groĂe Mengen zusĂ€tzlicher Trainingsdaten zu generieren. Die Trainingsdaten werden mit klassischen Solvern generiert, die zu jeder Formel nur eine von vielen möglichen Lösungen liefern. Es wird gezeigt, dass es ausreichend ist, an diesen speziellen Lösungen zu trainieren, sodass das neuronale Netz zur Semantik der Logik generalisiert. Das neuronale Netz kann Lösungen sogar fĂŒr Formeln aus Benchmarks aus der Literatur vorhersagen, bei denen der klassische Solver eine ZeitĂŒberschreitung hatte. ZusĂ€tzlich wird gezeigt, dass das neuronale Netz einen erheblichen Teil der Probleme aus dem jĂ€hrlichen Synthesewettbewerb (SYNTCOMP) und sogar Beispiele auĂerhalb der Distribution aus einer aktuellen Fallstudie lösen kann
Realizing Omega-regular Hyperproperties
We studied the hyperlogic HyperQPTL, which combines the concepts of trace
relations and -regularity. We showed that HyperQPTL is very expressive,
it can express properties like promptness, bounded waiting for a grant,
epistemic properties, and, in particular, any -regular property. Those
properties are not expressible in previously studied hyperlogics like HyperLTL.
At the same time, we argued that the expressiveness of HyperQPTL is optimal in
a sense that a more expressive logic for -regular hyperproperties would
have an undecidable model checking problem. We furthermore studied the
realizability problem of HyperQPTL. We showed that realizability is decidable
for HyperQPTL fragments that contain properties like promptness. But still, in
contrast to the satisfiability problem, propositional quantification does make
the realizability problem of hyperlogics harder. More specifically, the
HyperQPTL fragment of formulas with a universal-existential propositional
quantifier alternation followed by a single trace quantifier is undecidable in
general, even though the projection of the fragment to HyperLTL has a decidable
realizability problem. Lastly, we implemented the bounded synthesis problem for
HyperQPTL in the prototype tool BoSy. Using BoSy with HyperQPTL specifications,
we have been able to synthesize several resource arbiters. The synthesis
problem of non-linear-time hyperlogics is still open. For example, it is not
yet known how to synthesize systems from specifications given in branching-time
hyperlogics like HyperCTL.Comment: International Conference on Computer Aided Verification (CAV 2020
Compositional synthesis of reactive systems
Synthesis is the task of automatically deriving correct-by-construction implementations from formal specifications. While it is a promising path toward developing verified programs, it is infamous for being hard to solve. Compositionality is recognized as a key technique for reducing the complexity of synthesis. So far, compositional approaches require extensive manual effort. In this thesis, we introduce algorithms that automate these steps. In the first part, we develop compositional synthesis techniques for distributed systems. Providing assumptions on other processes' behavior is fundamental in this setting due to inter-process dependencies. We establish delay-dominance, a new requirement for implementations that allows for implicitly assuming that other processes will not maliciously violate the shared goal. Furthermore, we present an algorithm that computes explicit assumptions on process behavior to address more complex dependencies. In the second part, we transfer the concept of compositionality from distributed to single-process systems. We present a preprocessing technique for synthesis that identifies independently synthesizable system components. We extend this approach to an incremental synthesis algorithm, resulting in more fine-grained decompositions. Our experimental evaluation shows that our techniques automate the required manual efforts, resulting in fully automated compositional synthesis algorithms for both distributed and single-process systems.Synthese ist die Aufgabe korrekte Implementierungen aus formalen Spezifikation abzuleiten. Sie ist zwar ein vielversprechender Weg fĂŒr die Entwicklung verifizierter Programme, aber auch dafĂŒr bekannt schwer zu lösen zu sein. KompositionalitĂ€t gilt als eine SchlĂŒsseltechnik zur Verringerung der KomplexitĂ€t der Synthese. Bislang erfordern kompositionale AnsĂ€tze einen hohen manuellen Aufwand. In dieser Dissertation stellen wir Algorithmen vor, die diese Schritte automatisieren. Im ersten Teil entwickeln wir kompositionale Synthesetechniken fĂŒr verteilte Systeme. Aufgrund der AbhĂ€ngigkeiten zwischen den Prozessen ist es in diesem Kontext von grundlegender Bedeutung, Annahmen ĂŒber das Verhalten der anderen Prozesse zu treffen. Wir etablieren Delay-Dominance, eine neue Anforderung fĂŒr Implementierungen, die es ermöglicht, implizit anzunehmen, dass andere Prozesse das gemeinsame Ziel nicht böswillig verletzen. DarĂŒber hinaus stellen wir einen Algorithmus vor, der explizite Annahmen ĂŒber das Verhalten anderer Prozesse ableitet, um komplexere AbhĂ€ngigkeiten zu berĂŒcksichtigen. Im zweiten Teil ĂŒbertragen wir das Konzept der KompositionalitĂ€t von verteilten auf Einzelprozesssysteme. Wir prĂ€sentieren eine Vorverarbeitungmethode fĂŒr die Synthese, die unabhĂ€ngig synthetisierbare Systemkomponenten identifiziert. Wir erweitern diesen Ansatz zu einem inkrementellen Synthesealgorithmus, der zu feineren Dekompositionen fĂŒhrt. Unsere experimentelle Auswertung zeigt, dass unsere Techniken den erforderlichen manuellen Aufwand automatisieren und so zu vollautomatischen Algorithmen fĂŒr die kompositionale Synthese sowohl fĂŒr verteilte als auch fĂŒr Einzelprozesssysteme fĂŒhren
Z2SAL: a translation-based model checker for Z
Despite being widely known and accepted in industry, the Z formal specification language has not so far been well supported by automated verification tools, mostly because of the challenges in handling the abstraction of the language. In this paper we discuss a novel approach to building a model-checker for Z, which involves implementing a translation from Z into SAL, the input language for the Symbolic Analysis Laboratory, a toolset which includes a number of model-checkers and a simulator. The Z2SAL translation deals with a number of important issues, including: mapping unbounded, abstract specifications into bounded, finite models amenable to a BDD-based symbolic checker; converting a non-constructive and piecemeal style of functional specification into a deterministic, automaton-based style of specification; and supporting the rich set-based vocabulary of the Z mathematical toolkit. This paper discusses progress made towards implementing as complete and faithful a translation as possible, while highlighting certain assumptions, respecting certain limitations and making use of available optimisations. The translation is illustrated throughout with examples; and a complete working example is presented, together with performance data
Model Checking Communicating Processes: Run Graphs, Graph Grammars, and MSO
The formal model of recursive communicating processes (RCPS) is important in practice but does not allows to derive decidability results for model checking questions easily. We focus a partial order representation of RCPSâs execution by graphsâso called run graphs, and suggest an underapproximative verification approach based on a bounded-treewidth requirement. This allows to directly derive positive decidability results for MSO model checking (seen as partial order logic on run graphs) based on a context-freeness argument for restricted classes run graph
Inferring Properties in Computation Tree Logic
We consider the problem of automatically inferring specifications in the
branching-time logic, Computation Tree Logic (CTL), from a given system.
Designing functional and usable specifications has always been one of the
biggest challenges of formal methods. While in recent years, works have focused
on automatically designing specifications in linear-time logics such as Linear
Temporal Logic (LTL) and Signal Temporal Logic (STL), little attention has been
given to branching-time logics despite its popularity in formal methods. We
intend to infer concise (thus, interpretable) CTL formulas from a given finite
state model of the system in consideration. However, inferring specification
only from the given model (and, in general, from only positive examples) is an
ill-posed problem. As a result, we infer a CTL formula that, along with being
concise, is also language-minimal, meaning that it is rather specific to the
given model. We design a counter-example guided algorithm to infer a concise
and language-minimal CTL formula via the generation of undesirable models. In
the process, we also develop, for the first time, a passive learning algorithm
to infer CTL formulas from a set of desirable and undesirable Kripke
structures. The passive learning algorithm involves encoding a popular CTL
model-checking procedure in the Boolean Satisfiability problem
- âŠ