Specification Of Concurrent Systems Research Articles

Specification and verification of concurrent systems by causality and realizability

A logical theory for interface specification and verification of distributed, concurrent, interactive, real-time systems is worked out based on a semantic foundation including operational and denotational semantics. It supports a calculus for the specification and verification of concurrent interactive systems by interface assertions. Systems are composed acting concurrently and interacting via streams exchanged over their channels forming feedback loops. A denotational semantics is defined handling feedback communication by recursion and fixpoints based on strong causality and realizability instead of monotonicity. The resulting verification calculus for the specification logic is proved to be sound and relatively complete with respect to an operational semantics in terms of generalized Moore machines. Actually, two models of concurrent systems are defined, a more abstract one with communication and interaction modeled by untimed streams and a more concrete one working with timed streams. The untimed model is an abstraction of the timed model. The timed model allows expressing the laws of causality and realizability. Moreover, the timed model can be used to specify real-time properties.

The Maude strategy language

Rewriting logic is a natural and expressive framework for the specification of concurrent systems and logics. The Maude specification language provides an implementation of this formalism that allows executing, verifying, and analyzing the represented systems. These specifications declare their objects by means of terms and equations, and provide rewriting rules to represent potentially non-deterministic local transformations on the state. Sometimes a controlled application of these rules is required to reduce non-determinism, to capture global, goal-oriented or efficiency concerns, or to select specific executions for their analysis. That is what we call a strategy. In order to express them, respecting the separation of concerns principle, a Maude strategy language was proposed and developed. The first implementation of the strategy language was done in Maude itself using its reflective features. After ample experimentation, some more features have been added and, for greater efficiency, the strategy language has been implemented in C++ as an integral part of the Maude system. This paper describes the Maude strategy language along with its semantics, its implementation decisions, and several application examples from various fields.

Interface Automata for Shared Memory

Interface theories based on Interface Automata (IA) are formalisms for the component-based specification of concurrent systems. Extensions of their basic synchronization mechanism permit the modelling of data, but are studied in more complex settings involving modal transition systems or do not abstract from internal computation. In this article, we show how de Alfaro and Henzinger’s original IA theory can be conservatively extended by shared memory data, without sacrificing simplicity or imposing restrictions. Our extension IA for shared Memory (IAM) decorates transitions with pre- and post-conditions over algebraic expressions on shared variables, which are taken into account by IA’s notion of component compatibility. Simplicity is preserved as IAM can be embedded into IA and, thus, accurately lifts IA’s compatibility concept to shared memory. We also provide a ground semantics for IAM that demonstrates that our abstract handling of data within IA’s open systems view is faithful to the standard treatment of data in closed systems.

Strategies, model checking and branching-time properties in Maude

Rewriting logic and its implementation Maude are a natural and expressive framework for the specification of concurrent systems and logics. Its nondeterministic local transformations are described by rewriting rules, which can be controlled at a higher level using a builtin strategy language added to Maude 3. This specification resource would not be of much interest without tools to analyze their models, so in a previous work, we extended the Maude LTL model checker to verify strategy-controlled systems. In this paper, CTL* and μ-calculus are added to the repertoire of supported logics, after discussing which adaptations are needed for branching-time properties. The new extension relies on some external model checkers that are exposed the Maude models through general and efficient connections, profitable for future extensions and further applications. The performance of these model checkers is compared.

Specifying reversibility with TLA+

In the past, action-based, process-algebraic formalisms for the description and analysis of concurrent reversible computations were mainly developed. In this paper, we present a state-based approach to the specification of concurrent systems in which forward-executed actions may either be executed in reverse in a causal-consistent uncontrolled fashion or are irreversible. The basic underlying system semantics is assumed to be a set of possible infinite sequences of states with actions defined as state transitions, which allows us to specify reversibility with the specification language TLA+ and to use its tool support for specification editing and verification. We provide definitions of TLA+ operators for the specification of causal-consistent reversibility and irreversible actions in a uniform way. The reversibility is achieved by remembering as much computation history as necessary with regard to the irreversible actions. The applicability of the approach is illustrated with examples, including the modelling of the influence of the Raf kinase inhibitor protein on the extracellular signal-regulated kinase signalling pathway and parameterised specification of a system of dining philosophers.

A linear-time branching-time perspective on interface automata

Over the past two decades, de Alfaro and Henzinger’s interface automata (IA) have become a popular formal framework for the component-based specification of concurrent systems. IA’s parallel composition assumes that a component may wait on inputs but never on outputs, implying that an output must be consumed immediately or a communication error occurs. By now, the literature contains a number of semantics for IA: linear-time semantics based on traces observing communication errors, quiescence and/or divergence, as well as branching-time semantics based on alternating simulation. This article surveys these semantics from Rob van Glabbeek’s linear-time branching-time perspective, which does not consider settings with communication errors. We shed light onto the subtleties implied by IA’s pruning of all behaviour that might lead a component to autonomously enter an error state, and investigate when exactly de Alfaro and Henzinger’s restriction of input-determinism is needed. In addition, we introduce several new semantics for IA, in particular the linear-time ready semantics and the branching-time ready simulation.

Logic-based specification and verification of homogeneous dynamic multi-agent systems

We develop a logic-based framework for formal specification and algorithmic verification of homogeneous and dynamic concurrent multi-agent transition systems. Homogeneity means that all agents have the same available actions at any given state and the actions have the same effects regardless of which agents perform them. The state transitions are therefore determined only by the vector of numbers of agents performing each action and are specified symbolically, by means of conditions on these numbers definable in Presburger arithmetic. The agents are divided into controllable (by the system supervisor/controller) and uncontrollable, representing the environment or adversary. Dynamicity means that the numbers of controllable and uncontrollable agents may vary throughout the system evolution, possibly at every transition. As a language for formal specification we use a suitably extended version of Alternating-time Temporal Logic, where one can specify properties of the type “a coalition of (at least) n controllable agents can ensure against (at most) m uncontrollable agents that any possible evolution of the system satisfies a given objective gamma″, where gamma is specified again as a formula of that language and each of n and m is either a fixed number or a variable that can be quantified over. We provide formal semantics to our logic {mathcal {L}}_{textsc {hdmas}} and define normal form of its formulae. We then prove that every formula in {mathcal {L}}_{textsc {hdmas}} is equivalent in the finite to one in a normal form and develop an algorithm for global model checking of formulae in normal form in finite HDMAS models, which invokes model checking truth of Presburger formulae. We establish worst case complexity estimates for the model checking algorithm and illustrate it on a running example.

Distribution-Based Behavioral Distance for Nondeterministic Fuzzy Transition Systems

Modal logics and behavioral equivalences play an important role in the specification and verification of concurrent systems. In this paper, we first present a new notion of bisimulation for nondeterministic fuzzy transition systems, which is distribution based and coarser than state-based bisimulation appeared in the literature. Then, we define a distribution-based bisimilarity metric as the least fixed point of a suitable monotonic function on a complete lattice, which is a behavioral distance and is a more robust way of formalizing behavioral similarity between states than bisimulations. We also propose an on-the-fly algorithm for computing the bisimilarity metric. Moreover, we present a fuzzy modal logic and provide a sound and complete characterization of the bisimilarity metric. Interestingly, this characterization holds for a class of fuzzy modal logics. In addition, we show the nonexpansiveness of a typical parallel composition operator with respect to the bisimilarity metric, which makes compositional verification possible.

Hierarchical System Design Using Refinable Recursive Petri Net

This paper is in the framework of the specification and verification of concurrent dynamic systems. For this purpose we propose the model of Refinable Recursive Petri Nets (RRPN) under a maximality semantics. In this model a notion of undefined transitions is considered. The underlying semantics model is the Maximality Abstract Labeled Transition System (AMLTS). Then, the model supports a definition of a hierarchical design methodology. The example of a cutting flame machine is used for illustrating the approach.

Formal Specification and Verification of Self-Adaptive Concurrent Systems

The assurance of required quality properties is one of the major challenges in self-adaptive systems (SASs). SASs have the capability to adapt their dynamic behavior autonomously at runtime due to uncertain changes in the environment. In general, an SAS is much difficult to specify and verify, because of its highly complex internal behavior and especially when time constraints are involved. In this research, we use modal $\mu $ -calculus ( $\mathcal {M_{\mu }}$ ) for the specification and verification of colored Petri nets-based self-adaptive concurrent systems. We propose self-adaptive multi-agent concurrent system (SMACS) framework that is specifically designed for complex architectures. The internal structure of SMACS framework is based on MAPE-K feedback loop. Each phase of the feedback loop works as an internal agent (Int-Agent) known as Monitor Int-Agent, Analyzer Int-Agent, Planer Int-Agent, and Executer Int-Agent. The decentralized approach is being used in this research, and due to this approach, all agents intelligently adapt their behavior in the environment and send updates to other agents. For verification of internal properties like liveness, safeness, and deadlock-freedom of each agent, the TAPA model checker is being used. For the implementation of SMACS framework, traffic monitoring system is chosen as a case study.

Derivatives and partial derivatives for regular shuffle expressions

There is a rich variety of shuffling operations ranging from asynchronous interleaving to various forms of synchronizations. We introduce a general shuffling operation which subsumes earlier forms of shuffling. We further extend the notion of a Brzozowski derivative and an Antimirov partial derivative to the general shuffling operation and thus to many earlier forms of shuffling. This extension enables the direct construction of automata from regular expressions involving shuffles that appear in specifications of concurrent systems.

A mechanism of function calls in MSVL

Modeling, Simulation and Verification Language (MSVL) is a useful formalism for specification and verification of concurrent systems. To make it more practical and easier to use, we extend MSVL with external and internal function calls. To do so, the syntax of function definitions and function calls is formalized. Then, the syntax of expressions in MSVL is extended by including function calls. Further, the evaluation rules are redefined. Moreover, the set of statements in MSVL is also extended and the semantics of function call statements is formalized. In addition, the existence of minimal models of MSVL programs involving new added statements is proved. Finally, an example is given to illustrate how to interpret function calls in practice with MSVL.

Untanglings: a novel approach to analyzing concurrent systems

Abstract Substantial research efforts have been expended to deal with the complexity of concurrent systems that is inherent to their analysis, e.g., works that tackle the well-known state space explosion problem. Approaches differ in the classes of properties that they are able to suitably check and this is largely a result of the way they balance the trade-off between analysis time and space employed to describe a concurrent system. One interesting class of properties is concerned with behavioral characteristics. These properties are conveniently expressed in terms of computations, or runs , in concurrent systems. This article introduces the theory of untanglings that exploits a particular representation of a collection of runs in a concurrent system. It is shown that a representative untangling of a bounded concurrent system can be constructed that captures all and only the behavior of the system. Representative untanglings strike a unique balance between time and space, yet provide a single model for the convenient extraction of various behavioral properties. Performance measurements in terms of construction time and size of representative untanglings with respect to the original specifications of concurrent systems, conducted on a collection of models from practice, confirm the scalability of the approach. Finally, this article demonstrates practical benefits of using representative untanglings when checking various behavioral properties of concurrent systems.

Heuristic search for equivalence checking

Equivalence checking plays a crucial role in formal verification since it is a natural relation for expressing the matching of a system implementation against its specification. In this paper, we present an efficient procedure, based on heuristic search, for checking well-known bisimulation equivalences for concurrent systems specified through process algebras. The method tries to improve, with respect to other solutions, both the memory occupation and the time required for proving the equivalence of systems. A prototype has been developed to evaluate the approach on several examples of concurrent system specifications.

Model checking processes specified in join-calculus algebra

This article presents a model checking tool used to verify concurrent systems specified in join-calculus algebra. The temporal properties of systems under verification are expressed in CTL logic. Join-calculus algebra with its operational semantics defined by the chemical abstract machine serves as the basic method for the specification of concurrent systems and their synchronization mechanisms, and allows the examination of more complex systems.

A Formal Framework for Specifying Concurrent Systems

Concurrent systems are very complex and error-prone because these systems are associated with significant issues, such as deadlock, starvation, communication, non-deterministic behavior and synchronization. Using formal methods, which are based on mathematical notions and theories, can help to increase confidence in these systems. Thus in recent years, most efforts have focused to specify, verify and develop concurrent systems formally. However, with specifications that have been done up to this time, several important aspects of concurrent systems, such as dynamic process creation, scheduling, starvation and infinite execution have not been specified formally yet. On the other hand, some specified aspects, such as deadlock, synchronization and communication have not been described as completely and accurately and/or have been specified using a combination of several different methods and formalisms so that the integration of existing specifications needs too much effort. It can be said unequivocally that until now there is no specification framework, based on a single formalism, for concurrent systems in which all important aspects of these systems are considered. Thus, our previous work tried to present an integrated formal specification framework of all the extracted aspects based on just one formal notation, i.e., the Z language. In this paper, the details of the mentioned formal framework are first presented. Then, this framework is evaluated from two viewpoints: comprehensiveness of the framework itself and appropriateness of Z to write an integrated formal specification of concurrent systems.

ITL semantics of composite Petri nets

interval temporal logic (itl) and Petri nets are two well developed formalisms for the specification and analysis of concurrent systems. itl allows one to specify both the system design and correctness requirements within the same logic based on intervals (sequences of states). As a result, verification of system properties can be carried out by checking that the formula describing a system implies the formula describing a requirement. Petri nets, on the other hand, have action and local state based semantics which allows for a direct expression of causality aspects in system behaviour. As a result, verification of system properties can be carried out using partial order reductions or invariant based techniques. In this paper, we investigate a basic semantical link between temporal logics and compositionally defined Petri nets. In particular, we aim at providing a support for the verification of behavioural properties of Petri nets using methods and techniques developed for itl.

Defining Fairness in Reactive and Concurrent Systems

We define when a linear-time temporal property is a fairness property with respect to a given system. This captures the essence shared by most fairness assumptions that are used in the specification and verification of reactive and concurrent systems, such as weak fairness, strong fairness, k -fairness, and many others. We provide three characterizations of fairness: a language-theoretic, a game-theoretic, and a topological characterization. It turns out that the fairness properties are the sets that are “large” from a topological point of view, that is, they are the co-meager sets in the natural topology of runs of a given system. This insight provides a link to probability theory where a set is “large” when it has measure 1. While these two notions of largeness are similar, they do not coincide in general. However, we show that they coincide for ω -regular properties and bounded Borel measures. That is, an ω -regular temporal property of a finite-state system has measure 1 under a bounded Borel measure if and only if it is a fairness property with respect to that system. The definition of fairness leads to a generic relaxation of correctness of a system in linear-time semantics. We define a system to be fairly correct if there exists a fairness assumption under which it satisfies its specification. Equivalently, a system is fairly correct if the set of runs satisfying the specification is topologically large. We motivate this notion of correctness and show how it can be verified in a system.

Scheduling and control of real-time systems based on a token player approach

Petri nets are a powerful formalism for the specification and verification of concurrent systems, such as sequential systems and manufacturing systems. To deal with real-time systems whose time issues become essential, different extensions of Petri nets with time have been proposed in the literature. In this paper, a new scheduling and control technique for real-time systems modeled by ordinary P-time Petri nets is proposed. Its goal is to provide a scheduling for a particular firing sequence, without any violation of timing constraints ensuring that no deadline is missed. It is based on the firing instant notion and it consists in determining an inequality system generated for a possible evolution (in terms of a feasible firing sequence for the untimed underlying Petri net) of the model. This system can be used to check reachability problems as well as evaluating the performances of the model considered and determining the associated control for a definite functioning mode and it introduces partial order on the execution of particular events.

Generating a Petri net from a CSP specification: A semantics-based method

The specification and simulation of complex concurrent systems is a difficult task due to the intricate combinations of message passing and synchronizations that can occur between the components of the system. Two of the most extended formalisms used to specify, verify and simulate such kind of systems are CSP and the Petri nets. This work introduces a new technique that allows us to automatically transform a CSP specification into an equivalent Petri net. The transformation is formally defined by instrumenting the operational semantics of CSP. Because the technique uses a semantics-directed transformation, it produces Petri nets that are closer to the CSP specification and thus easier to understand. This result is interesting because it allows CSP developers not only to graphically animate their specifications through the use of the equivalent Petri net, but it also allows them to use all the tools and analysis techniques developed for Petri nets.