An incremental verification technique using decomposition of petri nets

In this paper we develop an intermittent communication framework for teams of mobile robots. Robots move along the edges of a mobility graph and communicate only when they meet at the vertices of this graph, giving rise to a dynamic communication network. We design distributed controllers for the robots that determine meeting times at the nodes of the mobility graph so that connectivity of the communication network is ensured over time, infinitely often. We show that this requirement can be captured by a global Linear Temporal Logic (LTL) formula that forces robots to meet infinitely often at the meeting points. To generate motion plans that satisfy the LTL expression, we propose a novel technique that approximately decomposes the global LTL formula into local LTL formulas and assigns them to the robots. Since the approximate decomposition of the LTL formula can result in conflicting robot behaviors, we develop a distributed conflict resolution scheme that generates conflict-free motion plans that satisfy the global LTL expression. By appropriately introducing delays in the execution of the generated motion plans we show that the proposed controllers can be executed asynchronously.

In this study, the author presents a new efficient algorithm for translating linear temporal logic (LTL) formulas to Buchi automata, which are used by LTL model checkers. The general idea of this algorithm is to generate Buchi automata from LTL formulas, using the principle of alternating automata and keeping only the positive transitions without generating the intermediate generalised automata. The LTL translation is the heart of any LTL model checker, which affects its performance. The translation performance is measured in addition to its speed and the size of the produced Buchi automaton (number of states and number of transitions), by correctness of produced Buchi automaton and its level of determinism. The author will show that this method is different from the others and it is very competitive with the most efficient translators to date.

A unified concurrent-composition method to state/event inference and concealment in labeled finite-state automata as discrete-event systems

Ordinary users can build their smart home automation system easily nowadays, but such user-customized systems could be error-prone. Using formal verification to prove the correctness of such systems is necessary. However, to conduct formal proof, formal specifications such as Linear Temporal Logic (LTL) formulas have to be provided, but ordinary users cannot author LTL formulas but only natural language.To address this problem, this paper presents a novel approach that can automatically generate formal LTL specifications from natural language requirements based on domain knowledge and our proposed ambiguity refining techniques. Experimental results show that our approach can achieve a high correctness rate of 95.4% in converting natural language sentences into LTL formulas from 481 requirements of real examples.

The problem of testing a linear temporal logic (LTL) formula on a finite execution trace of events, generated by an executing program, occurs naturally in runtime analysis of software. An algorithm which takes a past time LTL formula and generates an efficient dynamic programming algorithm is presented. The generated algorithm tests whether the formula is satisfied by a finite trace of events given as input and runs in linear time, its constant depending on the size of the LTL formula. The memory needed is constant, also depending on the size of the formula. Further optimizations of the algorithm are suggested. Past time operators suitable for writing succinct specifications are introduced and shown definitionally equivalent to the standard operators. This work is part of the PathExplorer project, the objective of which it is to construct a flexible framework for monitoring and analyzing program executions.

The paper presents an efficient algorithm for checking the satisfiability of a propositional linear time temporal logic formula, which may have past as well as future operators. This algorithm can be used to check validity of such formulas over all models as well as over computations of a finite-state program (model checking). Unlike previous theoretical presentations of a decision method for checking satisfiability or validity, whose first step is to construct the full set of all possible atoms of a tableau (satisfaction graph) and immediately pay the worst case exponential complexity price, the algorithm presented here builds the tableau incrementally. This means that the algorithm constructs only those atoms that are reachable from a possible initial atom, satisfying the formula to be checked.While incremental tableau construction for the future fragment of linear time temporal logic can be done in a single pass, the presence of past operators requires multiple passes that successively construct augmented versions of existing atoms, while still maintaining consistency and reachability.The proof of correctness of the algorithm is based on showing that any model of the considered formula is embedded as a path in the tableau at all the construction stages, and can be delineated when the construction terminates.The paper also describes an implementation of the algorithm with further attention to efficiency. This implementation is available as a support system for the book [8] under the name “temporal prover”. It has been used to verify all the propositional temporal formulas and to model-check all the finite-state programs appearing in the book.Keywordstemporal logicsatisfiability checkingvalidity checkingmodel checkingpast and future operatorsincremental tableauautomatic verification

This paper proposes a method to synthesise controllers for cyber-physical systems subjected to disturbances, such that the controlled system satisfies specifications given as linear temporal logic formulas. To solve this problem, a finite-state abstraction of the original system is first constructed, and then a controller is synthesised for the abstraction. Due to the disturbances and uncertainty in the environment, future states cannot be predicted exactly, and the abstraction must take this into account. For this purpose, the robust stutter bisimulation relation is introduced, which preserves the existence of controllers for any given linear temporal logic formula that excludes the next operator. States are related by the robust stutter bisimulation relation if the same target sets can be guaranteed to be reached or avoided under control of some controller, thus ensuring that disturbances have similar effect on paths that start in related states. It is shown that there exists a controller enforcing a linear temporal logic formula for the original system if and only if a controller exists for the abstracted system. The approach is illustrated by a robot navigation example.

We develop a sampling-based motion planning algorithm that combines long-term temporal logic goals with short-term reactive requirements. The mission specification has two parts: (1) a global specification given as a linear temporal logic (LTL) formula over a set of static service requests that occur at the regions of a known environment, and (2) a local specification that requires servicing a set of dynamic requests that can be sensed locally during the execution. The proposed computational framework consists of two main ingredients: (a) an off-line sampling-based algorithm for the construction of a global transition system that contains a path satisfying the LTL formula; and (b) an on-line sampling-based algorithm to generate paths that service the local requests, while making sure that the satisfaction of the global specification is not affected. The off-line algorithm has four main features. First, it is incremental, in the sense that the procedure for finding a satisfying path at each iteration scales only with the number of new samples generated at that iteration. Second, the underlying graph is sparse, which implies low complexity for the overall method. Third, it is probabilistically complete. Fourth, under some mild assumptions, it has the best possible complexity bound. The on-line algorithm leverages ideas from LTL monitoring and potential functions to ensure progress towards the satisfaction of the global specification while servicing locally sensed requests. Examples and experimental trials illustrating the usefulness and the performance of the framework are included.

The Specification Pattern System (SPS) and the Property Specification (Prospec) tool assist a user in generating formal specifications in Linear Temporal Logic (LTL), as well as other languages, from property patterns and scopes. Patterns are high-level abstractions that provide descriptions of common properties, and scopes describe the extent of program execution over which the property holds. The purpose of the work presented in this paper is to verify that the generated LTL formulas match the natural language descriptions, timelines, and traces of computation that describe the pattern and scope. The LTL formulas were verified using the Spin model checker on test cases developed using boundary value analysis and equivalence class testing strategies. A test case is an LTL formula and a sequence of Boolean valuations. The LTL formulas were those generated from SPS and Prospec. The Boolean valuations of propositions in the LTL formula are generated by a deterministic, single-threaded Promela program that was run using the software model-checker Spin. For each pattern, a suite of test cases was. The experiments uncovered several errors in both the SPS-generated and the Prospec-generated formulas.

In this paper we develop an intermittent communication framework for mobile robot networks. Intermittent communication provides significantly more flexibility to the robots to accomplish their tasks compared to approaches that enforce communication constraints for all time. We consider robots that move along the edges of a mobility graph and communicate only when they meet at the nodes of that graph giving rise to a dynamic communication network. Assuming that the mobility graph is connected, we design distributed controllers for the robots that determine meeting times at the vertices of the mobility graph so that connectivity of the communication network is ensured over time, infinitely often. We show that this requirement can be captured by a global Linear Temporal Logic (LTL) formula that forces robots to meet infinitely often at the rendezvous points. To generate discrete high-level motion plans for all robots that satisfy the LTL expression, we propose a novel technique that performs an approximate decomposition of the global LTL expression into local LTL expressions and assigns them to the robots. Since the approximate decomposition of the global LTL formula can result in conflicting robot behaviors, we develop a distributed conflict resolution scheme that generates discrete motion plans for every robot, based on the assigned local LTL expressions, whose composition satisfies the global LTL formula. Computer simulations are provided that verify the efficacy of the proposed distributed control scheme.

In this paper, we investigate the design of multirobot warehouse automation systems with complex high-level tasks. We consider a warehouse environment where a group of AGVs move in a grid-partitioned workspace to deliver goods upon requests automatically. The design objective is to synthesize a high-level controller/planner that coordinates the multi-robot system to fulfill the entire task. We use linear temporal logic (LTL) formulas to describe the desired task specifications. Then the controller is generated automatically based on the LTL formula using the theory of reactive synthesis. Compared with most of the existing planning algorithms for warehouse systems, the proposed method is formal in the sense that: (i) the controller is correct-by-construction with provably satisfication guarantees; (ii) it can handle complex temporal tasks in a user-friendly manner; (iii) our framework can also handle the situation of multiple robots with multiple requests. Finally, we implement the proposed synthesis procedure and illustrate our results for multi-robot systems by simulations.

Declarative process models consist of temporal constraints that a process must satisfy during execution. Constraint templates are patterns that define parameterized classes of properties. Their semantics can be formalized using formal logics such as Linear Temporal Logic (LTL) over finite traces. There exists a big amount of different constraint templates for different purposes. In practice, the variety of different templates yields complexity and performance issues with regard to model comparison, compliance checking and in particular process mining. In this paper we give a comprehensively overview about existing declare templates and transform their underlying LTL formula into the positive normal form (PNF), a canonical standard form for LTL formulas. On this basis, we present an algorithm for detecting declare templates in any LTL formula fulfilling the conditions for PNF. We reduce the number of process constraints that have to be proven by the algorithm to speed up the runtime and give some advice for further optimizations.

Journal Article A Syntactical Proof of the Canonical Reactivity Form for Past Linear Temporal Logic Get access Dimitar P. Guelev Dimitar P. Guelev Institute of Mathematics and Informatics, Bulgarian Academy of Sciences, Sofia, Bulgaria. Search for other works by this author on: Oxford Academic Google Scholar Journal of Logic and Computation, Volume 18, Issue 4, August 2008, Pages 615–623, https://doi.org/10.1093/logcom/exn002 Published: 06 February 2008 Article history Received: 22 January 2007 Published: 06 February 2008

Responsibility anticipation is the process of determining if the actions of an individual agent may cause it to be responsible for a particular outcome. This can be used in a multi-agent planning setting to allow agents to anticipate responsibility in the plans they consider. The planning setting in this paper includes partial information regarding the initial state and considers formulas in linear temporal logic as positive or negative outcomes to be attained or avoided. We firstly define attribution for notions of active, passive and contributive responsibility, and consider their agentive variants. We then use these to define the notion of responsibility anticipation. We prove that our notions of anticipated responsibility can be used to coordinate agents in a planning setting and give complexity results for our model, discussing equivalence with classical planning. We also present an outline for solving some of our attribution and anticipation problems using PDDL solvers.

We study the automatic synthesis of fair non-repudiation protocols, a class of fair exchange protocols, used for digital contract signing. First, we show how to specify the objectives of the participating agents, the trusted third party (TTP) and the protocols as path formulas in Linear Temporal Logic (LTL) and prove that the satisfaction of the objectives of the agents and the TTP imply satisfaction of the protocol objectives. We then show that weak (co-operative) co-synthesis and classical (strictly competitive) co-synthesis fail in synthesizing these protocols, whereas assume-guarantee synthesis (AGS) succeeds. We demonstrate the success of assume-guarantee synthesis as follows: (a) any solution of assume-guarantee synthesis is attack-free ; no subset of participants can violate the objectives of the other participants without violating their own objectives; (b) the Asokan-Shoup-Waidner (ASW) certified mail protocol that has known vulnerabilities is not a solution of AGS; and (c) the Kremer-Markowitch (KM) non-repudiation protocol is a solution of AGS. To our knowledge this is the first application of synthesis to fair non-repudiation protocols, and our results show how synthesis can generate correct protocols and automatically discover vulnerabilities. The solution to assume-guarantee synthesis can be computed efficiently as the secure equilibrium solution of three-player graph games.