Real-time Temporal Logic Research Articles

Deductive Verification Method of Real-Time Safety Properties for Embedded Assembly Programs

It is important to verify both the correctness and real-time properties of embedded systems. However, as practical computer programs are represented by infinite state transition systems, specifying and verifying a computer program is difficult. Real-time properties are also important for embedded programs, but verifying the real-time properties of an embedded program is difficult. In this paper, we focus on verifying an embedded assembly program, in order to verify the real-time safety properties. We propose a deductive verification method to verify real-time safety properties, based on discrete time, as follows: (1) First, we construct a timed computational model including the execution time from the assembly program. We can specify an infinite state transition system including the execution time of the timed computational model. (2) Next, we verify whether a timed computational model satisfies RTLTL (Real-Time Linear Temporal Logic) formulas by deductive verification. We can specify real-time properties by RTLTL. By our proposed methods, we are able to achieve verification of the real-time safety properties of an embedded program.

One-Pass and Tree-Shaped Tableau Systems for TPTL and TPTLb+Past

In this paper, we propose a novel one-pass and tree-shaped tableau method for Timed Propositional Temporal Logic and for a bounded variant of its extension with past operators. Timed Propositional Temporal Logic (TPTL) is a real-time temporal logic, with an EXPSPACE-complete satisfiability problem, which has been successfully applied to the verification of real-time systems. In contrast to LTL, adding past operators to TPTL makes the satisfiability problem for the resulting logic (TPTL+P) non-elementary. In this paper, we devise a one-pass and tree-shaped tableau for both TPTL and bounded TPTL+P (TPTLb+P), a syntactic restriction introduced to encode timeline-based planning problems, which recovers the EXPSPACE-complete complexity. The tableau systems for TPTL and TPTLb+P are presented in a unified way, being very similar to each other, providing a common skeleton that is then specialised to each logic. In doing that, we characterise the semantics of TPTLb+P in terms of a purely syntactic fragment of TPTL+P, giving a translation that embeds the former into the latter. Soundness and completeness of the system are proved fully. In particular, we give a greatly simplified model-theoretic completeness proof, which sidesteps the complex combinatorial argument used by known proofs for the one-pass and tree-shaped tableau systems for LTL and LTL+P.

Symbolic model checking for discrete real-time systems

A considerably large class of critical applications run in distributed and real-time environments, and most of the correctness requirements of such applications must be expressed by time-critical properties. To enable the specification and verification of these properties in both qualitative and quantitative manners, we propose a new real-time temporal logic $\rm~{RTCTL^*}$, by incorporating both the quantitative (bounded) future and past temporal operators from the qualitative temporal logic $\rm~{CTL^*}$. First, we propose a symbolic method for constructing the temporal tester for arbitrary principally temporal formulas. A temporal tester is constructed as a non-deterministic transducer with a fresh boolean output variable, such that at any position the output variable is set to be true if and only if the corresponding formula holds starting from that position. Then we propose a symbolic model checking method for $\rm~{RTCTL^*}$ over finite-state transition systems with weak fairness constraints based on the compositionality of testers. The soundness and completeness of the model checking method, the expressiveness of $\rm~{RTCTL^*}$, and the complexity of the tester construction are described and proven. We have already implemented an efficient model checking prototype for the real-time linear temporal logic $\rm~{RTLTL}$, which is a quantifier-free version of $\rm~{RTCTL^*}$, by building upon the NuSMV model checker. The theoretical and the experimental results from the prototype both confirm that for checking bounded temporal formulae of the form $f\texttt{U}_{[0,b]}g$ or $f\texttt{S}_{[0,b]}g$, our method performs exponentially better than the translation-based method in NuSMV.

Parametric metric interval temporal logic

In this paper we focus on the role of parametric constants in real-time temporal logic and introduce the logic PMITL as a parametric extension of MITL. For this logic, we study decision problems which are the analogues of satisfiability, validity and model-checking problems for non-parametric temporal logic. We impose some restrictions on the use of the parameters: each parameter is used with a fixed polarity, parameters can appear only in one of the endpoints of the intervals, parametric linear expressions can be used only as right endpoints of the intervals. We show that, for parameter valuations yielding only non-singular intervals, the considered problems are all decidable and Expspace-complete, such as for the decision problems in MITL. Moreover, we show that if we relax any of the imposed restrictions, the problems become undecidable. We also investigate the computational complexity of these problems for natural fragments of PMITL, and show that for some meaningful fragments they can be solved in polynomial space and are Pspace-complete. Finally, we consider the decision problem of determining the truth of first-order queries over PMITL formulas where the parameters are used as variables that can be existentially or universally quantified. We solve this problem in several cases and exhibit an exponential-space algorithm.

A Formal Specification Framework for Designing and Verifying Reliable and Dependable Software for CNC Systems

As a distributed computing system, a CNC system needs to be operated reliably, dependably, and safely. How to design reliable and dependable software and perform effective verification for CNC systems becomes an important research problem. In this paper, we propose a new modeling method called TTM/ATRTTL (timed transition models/all-time real-time temporal logics) for specifying CNC systems. TTM/ATRTTL provides full supports for specifying hard real time and feedback that are needed for modeling CNC systems. We also propose a verification framework with verification rules and theorems and implement it with STeP and SF2STeP. The proposed verification framework can check reliability, dependability, and safety of systems specified by our TTM/ATRTTL method. We apply our modeling and verification techniques on an open architecture CNC (OAC) system and conduct comprehensive studies on modeling and verifying a system controller that is the key part of OAC. The results show that our method can effectively model and verify CNC systems and generate CNC software that can satisfy system requirements in reliability, dependability, and safety.

A fuzzy real-time temporal logic

High-level descriptions of real-time systems often use fuzzy notions of time that are left open to domain specific interpretations. In order to verify that a given implementation conforms to such loosely defined specifications, the typical approach is to verify the implementation to be correct within well defined limits of time tolerance. This approach determines whether the real-time requirements are met, but does not reflect how well it is met.Our goal in this paper is to prescribe the development of timed specifications using fuzzy notions of time, and to present a methodology for computing the quality of satisfaction of the specification on a given implementation using domain specific fuzzy membership functions. With this objective, we combine the notions of real-time interval temporal logic (like Metric Interval Temporal Logic) and fuzzy logic to derive FRTL, a fuzzy real-time temporal logic. The novelty of the proposed logic is in introducing the notion of fuzzy time intervals into the core fabric of conventional metric temporal logic. We present a method for evaluating the fuzzy truth of FRTL properties on finite traces. We discuss the motivation of computing the fuzzy truth towards evaluating the quality of control in time critical embedded control system applications. We also show that two important related problems from the domain of mixed-signal design verification, are subsumed by the proposed framework of analysis.

A survey on temporal logics for specifying and verifying real-time systems

Over the last two decades, there has been an extensive study of logical formalisms on specifying and verifying real-time systems. Temporal logics have been an important research subject within this direction. Although numerous logics have been introduced for formal specification of real-time and complex systems, an up to date survey of these logics does not exist in the literature. In this paper we analyse various temporal formalisms introduced for specification, including propositional/first-order linear temporal logics, branching temporal logics, interval temporal logics, real-time temporal logics and probabilistic temporal logics. We give decidability, axiomatizability, expressiveness, model checking results for each logic analysed. We also provide a comparison of features of the temporal logics discussed.

A Novel Algorithm for Intrusion Detection Based on RASL Model Checking

The interval temporal logic (ITL) model checking (MC) technique enhances the power of intrusion detection systems (IDSs) to detect concurrent attacks due to the strong expressive power of ITL. However, an ITL formula suffers from difficulty in the description of the time constraints between different actions in the same attack. To address this problem, we formalize a novel real-time interval temporal logic—real-time attack signature logic (RASL). Based on such a new logic, we put forward a RASL model checking algorithm. Furthermore, we use RASL formulas to describe attack signatures and employ discrete timed automata to create an audit log. As a result, RASL model checking algorithm can be used to automatically verify whether the automata satisfy the formulas, that is, whether the audit log coincides with the attack signatures. The simulation experiments show that the new approach effectively enhances the detection power of the MC-based intrusion detection methods for a number of telnet attacks, p-trace attacks, and the other sixteen types of attacks. And these experiments indicate that the new algorithm can find several types of real-time attacks, whereas the existing MC-based intrusion detection approaches cannot do that.

Abstraction In Model Checking Real-Time Temporal Logic of Knowledge

Model checking in real-time temporal logic of knowledge TACTLK confronts the same challenge as in traditional model checking, that is the state space explosion problem. In order to alleviate this problem, we present our abstraction techniques. For the real time part of TACTLK, that is TACTL, we adopt the abstract discrete clock valuations, and in this way the infinite state space of a real time interpreted system can be converted into a finite form. For the epistemic operator K in TACTLK, the definition of epistemic equivalent to an agent between abstract states is given, therefore, the corresponding equivalent relations can be deduced and which can be used to combine the abstract states, as a result, the state space of the real time interpreted system can be further simplified. Finally, we adopt a variant of the standard railroad crossing system to illustrate the effectiveness of our abstraction techniques.

A theory of sampling for continuous-time metric temporal logic

This article revisits the classical notion of sampling in the setting of real-time temporal logics for the modeling and analysis of systems. The relationship between the satisfiability of metric temporal logic (MTL) formulas over continuous-time models and over discrete-time models is studied. It is shown to what extent discrete-time sequences obtained by sampling continuous-time signals capture the semantics of MTL formulas over the two time domains. The main results apply to “flat” formulas that do not nest temporal operators and can be applied to the problem of reducing the verification problem for MTL over continuous-time models to the same problem over discrete time, resulting in an automated partial practically efficient discretization technique.

Timed automata for metric interval temporal logic formulae in prototype verification system

Based on analysis of the syntax structure and semantics model of the metric interval temporal logic (MITL) formulas, it is shown how to transform a formula written in the real-time temporal logic MITL formula into a fair timed automaton (TA) that recognizes its satisfying models with prototype verification system (PVS) in this paper. Both the tabular construction’s principles and the PVS implementation details are given for the different type of MITL formula according to the corresponding semantics interpretations. After this transformation procedure, specifications expressed with MITL formula can be verified formally in the timed automata framework developed previously.

Early Verification and Validation of Mission Critical Systems

Our world is increasingly relying on complex software and systems. In a growing number of fields such as transportation, finance, telecommunications, medical devices, they now play a critical role and require high assurance. To achieve this, it is imperative to produce high quality requirements. The KAOS goal-oriented requirements engineering methodology provides a rich framework for requirements elicitation and management of such systems.This paper demonstrates the practical industrial application of that methodology. The non-critical parts are modelled semi-formally using a graphical language for goal-oriented requirements engineering. When and where needed (ie. for critical parts of a system) the model can be specified at formal level using a real-time temporal logic. That formal level seamlessly extends the semi-formal level which can also help hide the formality for the non-specialist.To ensure at an early stage that the right system is being built and that the requirements model is right, validation and verification tools are applied on that model. Early verification checks help to discover missing requirements, overlooked assumptions or incorrect goal refinements. State machines generation from operations provides an executable model useful for validation purposes or for deriving an initial design. Acceptance test cases and runtime behavior monitors can also be derived from the model.The process is supported by an integrated toolbox implementing the above tools by a roundtrip mapping of KAOS requirements level notations to the languages of formal technology tools such as model-checkers, SAT engines or constraint solvers. A graphical visualization framework also significantly helps validation using domain-based representations.

Incremental specification with SCTL/MUS-T: a case study

The past decade witnessed a great advance in the field of timed formal methods for the specification and analysis of real-time and safety-critical systems. In this context, timed automata and real-time temporal logics provide a simple, and yet general, way to model and specify the behavior of these systems. At the same time, iterative and incremental development has been massively adopted in professional practice. In order to get closer to this current trend, timed formal methods should be adapted to such lifecycle structures, getting over their traditional role of verifying that a model meets a set of fixed requirements. In the pursuit of this ultimate aim, we propose SCTL/MUS-T, a timed methodology in which many-valuedness let deal with both the uncertainty and the disagreement which are pervasive and desirable in an iterative and incremental process. To illustrate the main ideas behind SCTL/MUS-T methodology this paper focuses on the specification, synthesis and verification of the well known steam-boiler case study.

Qualitative and quantitative specification of interorganisational workflows

An interorganisational workflow is essentially a system of concurrent independent entities that interact via the possibly unreliable exchange of messages. In order to enact a software process in a distributed workflow environment, the members must communicate with each other in order to exchange data values and synchronisation messages. Due to the fact that the qualitative and the quantitative descriptions of interorganisational workflows are of different natures, we opted for a methodology that uses two description techniques: one for the functional behaviour (process algebra) and one for the quantitative information (real-time temporal logic).

Deriving operational software specifications from system goals

Goal orientation is an increasingly recognized paradigm for eliciting, modeling, specifying and analyzing software requirements. Goals are statements of intent organized in AND/OR refinement structures; they range from high-level, strategic concerns to low-level, technical requirements on the software-to-be and assumptions on its environment. The operationalization of system goals into specifications of software services is a core aspect of the requirements elaboration process for which little systematic and constructive support is available. In particular, most formal methods assume such operational specifications to be given and focus on their a posteriori analysis.The paper considers a formal, constructive approach in which operational software specifications are built incrementally from higher-level goal formulations in a way that guarantees their correctness by construction. The operationalization process is based on formal derivation rules that map goal specifications to specifications of software operations; more specifically, these rules map real-time temporal logic specifications to sets of pre-, post- and trigger conditions. The rules define operationalization patterns that may be used for guiding and documenting the operationalization process while hiding all formal reasoning details; the patterns are formally proved correct once and for all. The catalog of operationalization patterns is structured according to a rich taxonomy of goal specification patterns.Our constructive approach to requirements elaboration requires a multiparadigm specification language that supports incremental reasoning about partial models. The paper also provides a formal semantics for goal operationalization and discusses several semantic features of our language that allow for such incremental reasoning.

Model-Generation of a Fictitious Clock Real-Time Logic Using Sharing Trees

We present first the logic mtl, a real-time temporal logic that is at the heart of the real-time specification language Albert. Since this logic is undecidable, we approximate it (using the theory of Abstract Interpretation) by its fictitious clock counterpart, MTLfc.We then present a symbolic tableau-based model generation decision procedure in ECLFC, which is theoretically optimal. In practice however, we see that the introduction of integer-valued prophecy variables will make it more efficient. From these variables, we reconstruct by reverting the process a logic that we call ExpSpace, which can be decided in PSpace, and has the same expressivity as MTLfc. Theory thus shows that memory space is the critical factor. However, the classical compaction of memory space by BDDs is not ideal here, since our integer variables would need to be encoded by booleans. Therefore, we use Sharing Trees instead, a compact data structure that can accommodate arbitrary data types. Preliminary results on this implementation are reported.

Engineering the Usability of a Visual Formalism for Real-time Temporal Logic

Visual formalisms merge the rigor of mathematical notations with the naturality of graphic representation. This increases usability of formal methods, and may also improve their verification power through a richer involvement of the user. To achieve this goal, development of the visual representation must fulfill a twofold requirement: on the one hand, the design must capture the inherent rigor of the underlying formalism; on the other, it must meet the final user intuition.In this paper, we introduce, motivate and evaluate a visual formalism for a real-time logic. The visual formalism supporting presentation of the logic was designed by joining heuristic design and user-based evaluation. Heuristic principles were applied to define a limited set of visualization metaphors supporting consistent representation of basic semantic constructs. Alternative representations were defined where multiple choices were possible with no obvious expected preference. Heuristic assumptions were then refined and alternative representations were selected by resorting to the judgment of a representative sample of target end-users. The resulting notation was implemented within an interactive syntax-directed editor, which was then used to carry out a competitive user-based evaluation of the usability of textual and visual representations.

PLC-automata: a new class of implementable real-time automata

We introduce PLC-automata as a new class of automata which are tailored to deal with real-time properties of programmable logic controllers (PLCs). These devices are often used in industrial practice to solve controlling problems. Nevertheless, PLC-automata are not restricted to PLCs, but can be seen as a model for all polling systems. A semantics in an appropriate real-time temporal logic (duration calculus) is given and an implementation schema that fits the semantics is presented in a programming language for PLCs. A case study is used to demonstrate the suitability of this approach. We define several parallel composition operators, and present an alternative semantics in terms of timed automata for which model-checkers are available.

A Contribution to the Validation of Grafcet Controlled Systems

Grafcet is a widely used model for the specification of logic control in manufacturing systems. Compared to other modelling tools for Programmable Logic Controllers (PLC), it has the advantages of manipulating simple concepts which are commonly used by control agents and engineers. This paper presents an approach based on the use of the “Timed Transition Model (TTM)/Real-Time Temporal Logic (RTTL)” formalism as a support to the analysis and verification of’ properties of automated systems whose controllers are specified using Grafcet. The modelled system is mapped into a TTM, and a dedicated proof system, based on abstractions and heuristics, is used for the validation of safety, liveness and timeliness properties expressed in RTTL.

Petri net model with fuzzy timing and fuzzy-metric temporal logic

This paper is concerned with a Petri net model having fuzzy timing and fuzzy real-time temporal logic. In an earlier paper, we introduced a Petri net model with four fuzzy set theoretic functions of time but no algorithms were given for computing the two important operators called, earliest and latest. In this paper, we first present algorithms for performing these two operations on fuzzy functions of time. Then we extend the existing concept of (real-time) metric temporal logic to fuzzy metric temporal logic by expressing the metrics for state and time constraints in terms of fuzzy possibility distributions. Finally we combine the two concepts of fuzzy-timing Petri net and fuzzy metric temporal logic to introduce a new Petri net model called the temporal-logic fuzzy-timing Petri net (TLFTN). The paper concludes with an algorithm and illustrative example for model checking using TLFTNs. © 1999 John Wiley & Sons, Inc.