Constructing an Interval Temporal Logic for Real-Time Systems

A real-time system is one that involves control of one or more physical devices with essential timing requirements. Examples of these systems are command and control systems, process control systems, flight control systems, and the space shuttle avionics systems. The characteristics of these systems are that severe consequences will occur if the logical and physical timing specifications of the systems are not met. Formal specification and verification are among the techniques to achieve reliable software for real-time systems, in which testing may be impossible or too dangerous to perform. This paper presents a modal logic, Interval Temporal , built upon a classical predicate logic In this logic system, we consider formulas that can be used to reason about timing properties of systems, in particular, responsiveness assertions. A responsiveness assertion describes constraints that a program must satisfy within an interval. Thus, it can be utilized to characterize behaviors of life-critical systems. We assume that a program P can be identified with a theory, a collection of formulas characterizing sequences of states of P with arbitrary initial states. In the following, we describe syntax and semantics of the logic, present a proof rule for responsiveness assertions, and show soundness and relative completeness of responsiveness assertions that we consider. There are other approaches to build temporal logics for real-time systems, which are included in bibliography

A Run-Time Decision Procedure for Responsive Computing Systems

A responsive computing system is a hybrid of real-time, distributed and fault-tolerant systems. In such a system, severe consequences will occur if the logical and physical specifications of the system are not met. In this paper, we present a logic, Interval Temporal Logic (ITL), to specify responsive systems and give decision procedures to verify properties of the system at run-time as follows. First, we collect, during execution, events occurring in the system to represent a distributed computation. Next, we specify properties of the system using ITL formulas. Finally, we apply the decision procedures to determine satisfaction of the formulas. Thus, we can verify properties of the system at run-time using these decision procedures

Operational Evaluation of Responsiveness Properties

In this paper, a new technique for ensuring run-time satisfaction of properties-specifically responsiveness property, a subset of liveness property, in responsive systems, is presented. Since whether the run-time behavior of a system is satisfied depends on the execution (operational) environment, we develop a translation which takes into account the constraints in the operational environment, and generates histories for each process in the system. Thus, every process can utilize its history to operationally evaluate the system behavior and signal errors if its history is violated. Therefore, this technique provides software safety, handles error-detection, and ensures run-time satisfaction of responsiveness property in the operational environment. To illustrate this approach a train set example is presented

Decidability and coincidence of equivalences for concurrency

There are two fundamental problems concerning equivalence relations in con-currency. One is: for which system classes is a given equivalence decidable? The second is: when do two equivalences coincide? Two well-known equivalences are history preserving bisimilarity (hpb) and hereditary history preserving bisimi-larity (hhpb). These are both ‘independence ’ equivalences: they reflect causal dependencies between events. Hhpb is obtained from hpb by adding a ‘back-tracking ’ requirement. This seemingly small change makes hhpb computationally far harder: hpb is well-known to be decidable for finite-state systems, whereas the decidability of hhpb has been a renowned open problem for several years; only recently it has been shown undecidable. The main aim of this thesis is to gain insights into the decidability problem for hhpb, and to analyse when it coincides with hpb; less technically, we might say, to analyse the power of the interplay between concurrency, causality, and conflict. We first examine the backtracking condition, and see that it has two dimen

Combating state explosion in the detection of dynamic properties of distributed computations

In the context of asynchronous distributed systems, many important applications depend on the ability to check that all observations of the execution of a distributed program, or distributed computation, satisfy a desired (or undesired) temporal evolution of states, or dynamic property. Examples include the implementation of distributed algorithms, automated testing via oracles, debugging, and building fault-tolerant applications through exception detection and handling. When a distributed program exhibits a high degree of concurrency, the number of possible observations of an execution can grow exponentially, quickly leading to an explosion in the amount of space and time required to check a dynamic property. In the worst case, detection of such properties may be defeated. This is the run-time counterpart of the well-known state explosion problem studied in model checking. In this thesis, we study the problem of state explosion as it arises in the detection of dynamic properties. In particular, we consider the potential of applying well-known techniques for dealing with state explosion from model checking to the case of dynamic property detection. Significant semantic similarities between the two problems means that there is great potential for deriving techniques for dealing with state explosion in dynamic property detection based on existing model checking techniques. However, differences between the contexts in which model checking and dynamic property detection take place mean that not all approaches to dealing with state explosion in model checking may carryover to the run-time case. We investigate these similarities and differences and provide the development and analysis of two approaches for combating state explosion in dynamic property detection based on model checking methods: on-the-fly automata theoretic model checking, and partial order reduction.EThOS - Electronic Theses Online ServiceGBUnited Kingdo