Temporal Logic Language Research Articles

A Petri nets-based modeling method for multi robot path planning

The construction of lunar bases is one of the core enabling technologies in current lunar exploration and development plans of various countries. However, to eliminate the constraints of high transportation costs and limited manned space technology, a new research plan is to employ multi robot teams to build lunar bases. The key to this solution is how to achieve path planning for complex tasks for multiple robots. Therefore, this article takes the exploration and collection area, lunar soil collection, and lunar soil transportation in the lunar base construction scene as complex task inputs, and studies a multi robot path planning modeling method based on Petri net model. Firstly, a Petri net model for multi robot motion was constructed. Meanwhile, linear temporal logic(LTL) language was used to describe the related tasks of lunar base construction. Finally, simulation validation was conducted in Matlab software and compared with the modeling method using switching systems. The results show that the total modeling time required for using the Petri net model is reduced by two orders of magnitude compared to the modeling time for a single task switching system model, indicating that the established Petri net multi robot model has advantages such as avoiding dimension explosion and computational efficiency.

VERIFICATION OF AUTOMATONS BY MODEL CHECKING METHOD

The article analyzes software verification of control systems based on finite state machines, presents a classification of software correctness checks, advantages and disadvantages of various approaches to software verification, and, as a result, justifies the use of static verification methods, namely the model checking method. To solve applied problems, it is proposed to use the NuSMV software verifier. A brief overview of NuSMV verifier is given. The route of verification of software written in automaton style by the method of model checking is described. Each stage is described in the example of two interacting automata method. The construction of the model is described from a verbal description of its transformation into a finite state machine model with intermediate states and the transformation of the automaton into a formal finite state machine model in the SMV language, which is the input data for the NuSMV verifier. A description of the requirements for the model is presented, ranging from a verbal description of the requirements to the formalization of requirements in language of the temporal logic CTL. Based on the obtained model in SMV language and the obtained formalization of the requirements in CTL temporal logic language, NuSMV verifier checks the feasibility of the obtained requirements on the obtained model of the automata system. An analysis of the results of verification according to the specified requirements is given. For verification, an error was introduced into the model, leading to a negative result of the feasibility of the specified requirements. The verifier indicated the presence of an error and the path leading to it. Based on the results of the analysis of the results, a conclusion is made about the need to use this verification method in tasks of responsible applications. Further steps for the development and implementation of this method are described.

COMPLETE INTUITIONISTIC TEMPORAL LOGICS FOR TOPOLOGICAL DYNAMICS

AbstractThe language of linear temporal logic can be interpreted on the class of dynamic topological systems, giving rise to the intuitionistic temporal logic ${\sf ITL}^{\sf c}_{\Diamond \forall }$ , recently shown to be decidable by Fernández-Duque. In this article we axiomatize this logic, some fragments, and prove completeness for several familiar spaces.

Efficient Automaton Theoretical Vacuity Detection for Formal Properties

Model checking is a powerful technique for verifying the correctness of systems with respect to the requirements. While some errors happen in the property, the model itself, or the environment, we think that satisfaction of the property is meaningless (vacuous) satisfaction. It misleads users of model-checking that a system is correct. Traditional temporal logic vacuity detection is based on a syntactic definition. It is undesirable because vacuity detection would depend on syntactic formalization choices that have no effect on the semantics. This article presents an automaton-based semantic vacuity detection method which synthesizes the property into the automaton and detects the vacuity by detecting the reachability of the automaton state. Compared with the traditional syntactic-based vacuity detection, the proposed method is well suited for detecting vacuity with respect to multiple occurrences of a sub-formula. At the same time, we do not distinguish the temporal logic language. As long as the property can be synthesized into an automaton, this method can be well applied. We extend the vacuity to the satisfaction of real-time properties. The real experiments show that this method is applied efficiently in practical vacuity detection. To our knowledge, it is the first attempt to present and solve practical vacuity in an automaton view.

Learning Temporal Causal Sequence Relationships from Real-Time Time-Series

We aim to mine temporal causal sequences that explain observed events (consequents) in time-series traces. Causal explanations of key events in a time-series have applications in design debugging, anomaly detection, planning, root-cause analysis and many more. We make use of decision trees and interval arithmetic to mine sequences that explain defining events in the time-series. We propose modified decision tree construction metrics to handle the non-determinism introduced by the temporal dimension. The mined sequences are expressed in a readable temporal logic language that is easy to interpret. The application of the proposed methodology is illustrated through various examples.

Games of influence

AbstractIn this paper, we present two models for reasoning about strategic actions in opinion diffusion. In both models, the agents are endowed with goals expressed compactly in a suitably defined language of linear temporal logic and are connected in an influence network which defines the underlying opinion diffusion process. The agents can act by exerting their influence or retain from it: in one case, we assume an initial state of incomplete information about the agents’ opinions, while in the other, we assume that the agents have complete information. We investigate the interplay between simple network structures (e.g. certain acyclic graphs) and the existence of game-theoretic solution concepts for the unanimity aggregator. We also give bounds for the computational complexity of strategic reasoning in both our models on arbitrary networks.

An intrusion detection algorithm for wireless networks based on ASDL

Wireless networks are more vulnerable to cyberattacks than cable networks. Compared with the misuse intrusion detection techniques based on pattern matching, the techniques based on model checking U+0028 MC U+0029 have a series of comparative advantages. However, the temporal logics employed in the existing latter techniques cannot express conveniently the complex attacks with synchronization phenomenon. To address this problem, we formalize a novel temporal logic language called attack signature description language U+0028 ASDL U+0029. On the basis of it, we put forward an ASDL model checking algorithm. Furthermore, we use ASDL programs, which can be considered as temporal logic formulas, to describe attack signatures, and employ other ASDL programs to create an audit log. As a result, the ASDL model checking algorithm can be presented for automatically verifying whether or not the latter programs satisfy the formulas, that is, whether or not the audit log coincides with the attack signatures. Thus, an intrusion detection algorithm based on ASDL is obtained. The case studies and simulations show that the new method can find coordinated chop-chop attacks.

Formal specification and verification of a distributed fault localization, isolation and supply restoration algorithm

Distributed fault localization, isolation and supply restoration (FLISR) algorithm only uses local topology information to improve system reliability in electric power enterprises. It has better adaptability than traditional centralized control architecture. To verify the correctness and reliabilit y of the distributed FLISR algorithm which applied to complex distribution network is very important in the operation of distribution network. A formal method for the specification and verification of the distributed FLISR algorithm which uses linear temporal logic (LTL) language is presented in this paper. In addition, the correctness of the algorithm in interference-free situation and the security of the algorithm in some uncertain interference such as switch action failure, communication failure and other confounding factors are proved mathematically.

A formal approach for the specification and verification of a Trustworthy Human Resource Discovery mechanism in the Expert Cloud

Expert Cloud as a new class of Cloud computing systems enables its users to request the skill, knowledge and expertise of people without any information of their location by employing Internet infrastructures and Cloud computing concepts. One of the most important service in Expert Cloud is to search trustworthy peoples in order to benefit from their knowledge and skills. In this paper we propose a new and applicable method for Trustworthy Human Resource Discovery (THRD) in Expert Cloud by introducing a resource discovery and trust evaluating method, implement the proposed method by using ASP.Net and SQL in Expert Cloud; verify the structures and compositions of THRD by describing the behavioral models and state diagrams; define a Kripke structure with marked states to provide the formal relationship between the expanded model and the original state diagram structures; define the expected properties of the structures and compositions of THRD by means of temporal logic languages; and implement the proposed model by NuSMV model checker. The results show that the proposed method can discover trustworthy people efficiently and is sound, complete, reachable, fair, deadlock-free and consistent.

Construction and verification of PLC LD programs by the LTL specification

An approach to the construction and verification of LD programs of programmable logic controllers (PLC) for discrete problems is proposed. The specification of the program behavior is performed using the linear temporal logic language (LTL). Programming is performed using the Ladder Diagram (LD) language by the LTL specification. The correctness analysis of the LTL specification is performed using the Cadence SMV symbolic model-checking tool. An approach to programming and verifying the PLC LD programs is shown using an example. The LD program, its LTL specification, and an SMV model are given for a discrete problem. This article is aimed at the description of an approach to PLC programming that will provide the correctness analysis of PLC LD programs using the model-checking method. Therefore, the variation in each programmable variable is described using a pair of LTL formulas. The first LTL formula describes situations in which the corresponding variable increases and the second LTL formula specifies conditions leading to a decrease in the variable. LTL formulas, which are considered to specify the behavior of variables, are constructive in the sense that the PLC program corresponding to the temporal properties expressed by these formulas is constructed by them. Thus, PLC programming is reduced to the construction of the LTL specification for the behavior of each programmed variable. In addition, the SMV model of the PLC LD program is constructed by the LTL specification. Then, the SMV model is analyzed for correctness (relative to additional conventional general-programming LTL properties) by the Cadence SMV symbolic model-checking tool.

An Aspect-oriented Software Architecture Description Language AO-ADL Based on XYZ

Aspect-Oriented Programming (AOP) can resolve the code tangling problem in ObjectOriented Programming (OOP) via using the technology of separation of concerns. Software architecture is becoming an important part in the phase of software design, it has the ability of helping designer to handle the structure and the complexity of large software systems, and Aspect-Oriented Software Development (AOSD) is a new paradigm proposed to manage the complexity by crosscutting concerns in the whole software life-cycle. In order to adequately specify aspect-oriented design, Aspect-Oriented Architecture Description Languages (AOADL) are needed. XYZ/ADL is an architecture description language which is based on temporal logic language XYZ/E. XYZ/ADL separates computation and communication into two different architecture elements – component and connector, but lacks some appropriate support to represent these crosscutting behaviors. So, XYZ/ADL must be extended to resolve the problem above by adding a kind of new elements – Aspect and modifying the former component and connector. At last, we illustrate them on an example of the Hotel Management System (HMS) via using AO- ADL.

Constraint LTL satisfiability checking without automata

This paper introduces a novel technique to decide the satisfiability of formulae written in the language of Linear Temporal Logic with both future and past operators and atomic formulae belonging to constraint system D (CLTLB(D) for short). The technique is based on the concept of bounded satisfiability, and hinges on an encoding of CLTLB(D) formulae into QF-EUD, the theory of quantifier-free equality and uninterpreted functions combined with D. Similarly to standard LTL, where bounded model-checking and SAT-solvers can be used as an alternative to automata-theoretic approaches to model-checking, our approach allows users to solve the satisfiability problem for CLTLB(D) formulae through SMT-solving techniques, rather than by checking the emptiness of the language of a suitable automaton. The technique is effective, and it has been implemented in our Zot formal verification tool.

Vibes: A visual language for specifying behavioral requirements of algorithms

Manually verifying the behavior of software systems with respect to a set of requirements is a time-consuming and error-prone task. If the verification is automatically performed by a model checker however, time can be saved, and errors can be prevented. To be able to use a model checker, requirements need to be specified using a formal language. Although temporal logic languages are frequently used for this purpose, they are neither commonly considered to have sufficient usability, nor always naturally suited for specifying behavioral requirements of algorithms. Such requirements can be naturally specified as regular language recognizers such as deterministic finite accepters, which however suffer from poor evolvability: the necessity to re-compute the recognizer whenever the alphabet of the underlying model changes. In this paper, we present the visual language Vibes that both is naturally suited for specifying behavioral requirements of algorithms, and enables the creation of highly evolvable specifications. Based on our observations from controlled experiments with 23 professional software engineers and 21 M.Sc. computer science students, we evaluate the usability of Vibes in terms of its understandability, learnability, and operability. This evaluation suggests that Vibes is an easy-to-use language.

A Framework for Proving the Correctness of Cryptographic Protocol Properties by Linear Temporal Logic

In this paper, a framework for cryptographic protocol analysis using linear temporal logic is proposed. The framework can be used to specify and analyse security protocols. It aims to investigate and analyse the security protocols properties that are secure or have any flaws. The framework extends the linear temporal logic by including the knowledge of participants in each status that may change over the time. It includes two main parts, the Language of Temporal Logic (LTL) and the domain knowledge. The ability of the framework is demonstrated by analysing the Needham-Schroeder public key protocol and the Andrew Secure RPC protocol as examples.

Towards Support for Software Model Checking: Improving the Efficiency of Formal Specifications

The Property Specification (Prospec) tool uses patterns and scopes defined by Dwyer et al., to generate formal specifications in Linear Temporal Logic (LTL) and other languages. The work presented in this paper provides improved LTL specifications for patterns and scopes over those originally provided by Prospec. This improvement comes in the efficiency of the LTL formulas as measured in terms of the number of states in the Büchi automaton generated for the formula. Minimizing the size of the Büchi automata for an LTL specification provides a significant improvement for model checking software systems using such tools as the highly acclaimed Spin model checker.

Linear temporal logic vehicle routing with applications to multi‐UAV mission planning

AbstractMissions with high combinatorial complexity involving several logical and temporal constraints often arise in cooperative control of multiple Uninhabited Aerial Vehicles. In this paper, we propose a new class of problems that generalizes the standard Vehicle Routing Problem (VRP) by addressing complex tasks and constraints on the mission, called the ‘mission specifications’, expressed in a high‐level specification language. In the generalized problem setup, these mission specifications are naturally specified using the Linear Temporal Logic language LTL−X. Using a novel systematic procedure, the LTL−Xspecification is converted to a set of constraints suitable to a Mixed‐Integer Linear Programming (MILP) formulation, which in turn can be incorporated into two widely‐used MILP formulations of the standard VRP. Solving the resulting MILP provides an optimal plan that satisfies the given mission specification. The paper also presents two mission planning applications. Copyright © 2011 John Wiley & Sons, Ltd.

Verification of synchronous-automaton programs with the use of LTL

A way to verify synchronous-automaton programs using the language of linear-time temporal logic with past-tense operators is proposed. The employment of the TempEst software tool is studied. The specification and checking of the properties are illustrated using the example of an alarm clock.

Temporal logic of linearly ordered α-spaces

Using the language of temporal logic, we construct a decidable calculus L* α and prove that the calculus is complete w.r.t. the class of all strictly linearly ordered α-frames.

Automated compositional proofs for real-time systems

We present a framework for formally proving that the composition of the behaviors of the different parts of a complex, real-time system ensures a desired global specification of the overall system. The framework is based on a simple compositional rely/guarantee circular inference rule, plus a methodology concerning the integration of the different parts into a whole system. The reference specification language is the TRIO metric linear temporal logic. The novelty of our approach with respect to existing compositional frameworks–most of which do not deal explicitly with real-time requirements–consists mainly in its generality and abstraction from any assumptions about the underlying computational model and from any semantic characterizations of the temporal logic language used in the specification. Moreover, the framework deals equally well with continuous and discrete time. It is supported by a tool, implemented on top of the proof-checker PVS, to perform deduction-based verification through theorem-proving of modular real-time axiom systems. As an example of application, we show the verification of a real-time version of the old-fashioned but still relevant “benchmark” of the dining philosophers problem.

Invariance under stuttering in a temporal logic of actions

We show that some simple and useful stutter-invariant properties definable in the language of Lamport's Simple Temporal Logic of Actions (STLA) are not definable in STLA and present a natural extension of STLA that allows one to express all stutter-invariant properties definable in the language of STLA.