Narrow Results

A temporal logic of causality (TLC) was introduced by Alur, Penczek, and Peled in [1]. It is basically a linear time temporal logic interpreted over Mazurkiewicz traces which allows quantification over causal chains. Through this device one can directly formulate causality properties of distributed systems. In this paper we consider an extension of TLC by strengthening the chain quantification operators. We show that our logic TLC* adds to the expressive power of TLC. We doso by defining an Ehrenfeucht-Fraïssé game to capture the expressive power of TLC. We then exhibit a property and by means of this game prove that the chosen property is not definable in TLC. We then show that the same property is definable in TLC*. We prove in fact the stronger result that TLC* is expressively stronger than TLC exactly when the dependency relation associated with the underlying trace alphabet is not transitive. We then show that TLC* defines only regular trace languages by embedding it into the monadic second-order logic. Finally, the relative expressive power of TLC* and similar logics for traces is compared.

A common characteristic of the new distributed systems is the increasing complexity. Useful paradigms to cope with the complexity of systems are modularity and compositionality. In this paper we define a compositional method to attack the state explosion problem in model checking. The method, given a formula to be checked on a system composed of a set of parallel processes, allows syntactically reducing in a modular way the processes, in order to reduce the state space of their composition. The reduction is formula driven and is based on a notion of equivalence between processes, which is a congruence w.r.t. the parallel composition operator.

We show that the class of Event Clock Automata [2] admit a logical characterisation via an unrestricted monadic second order logic interpreted over timed words. The result is interesting in that it provides an unrestricted yet decidable logical characterisation of a non-trivial class of timed languages. A timed temporal logic considered earlier in the literature [11] is shown to be expressively complete with respect to the monadic logic.

We introduce a family of temporal logics to specify the behavior of systems with Zeno behaviors. We extend linear-time temporal logic LTL to authorize models admitting Zeno sequences of actions and quantitative temporal operators indexed by ordinals replace the standard next-time and until future-time operators. Our aim is to control such systems by designing controllers that safely work on ω-sequences but interact synchronously with the system in order to restrict their behaviors. We show that the satisfiability and model-checking for the logics working on ω^k-sequences is EXPSPACE-complete when the integers are represented in binary, and PSPACE-complete with a unary representation. To do so, we substantially extend standard results about LTL by introducing a new class of succinct ordinal automata that can encode the interaction between the different quantitative temporal operators.

We propose a sound and complete compositional proof rule for distributed synthesis. Applying our proof rule only requires the manual strengthening of the specification into a conjunction of formulas that can be guaranteed by individual black-box processes. All premises of the proof rule can be checked automatically.

For this purpose, we give an automata-theoretic synthesis algorithm for single processes in distributed architectures. The behavior of the local environment of a process is unknown in the process of synthesis and cannot be assumed to be maximal. We therefore consider reactive environments that have the power to disable some of their own actions, and provide methods for synthesis (and realizability checking) in this setting. We establish upper bounds for CTL (2EXPTIME) and CTL* (3EXPTIME) synthesis with incomplete information, matching the known lower bounds for these problems, and provide matching upper and lower bounds for μ-calculus synthesis (2EXPTIME) with complete or incomplete information. Synthesis in reactive environments is harder than synthesis in maximal environments, where CTL, CTL* and μ-calculus synthesis are EXPTIME, 2EXPTIME and EXPTIME complete, respectively.

We study a modelling framework and computational paradigm called Colonies of Synchronizing Agents (CSAs), which abstracts intracellular and intercellular mechanisms of biological tissues. The model is based on a multiset of agents (cells) in a common environment (a tissue). Each agent has a local contents, stored in the form of a multiset of atomic objects (e.g., representing molecules), updated by multiset rewriting rules which may act on individual agents (intracellular action) or synchronize the contents of pairs of agents (intercellular action).

In this paper we investigate dynamic properties of CSAs, by means of temporal logic, and we give a logical characterization of some notions inspired by biology such as robustness, mutants and species. We reveal the relation that exists between the concept of robustness for CSAs and the bisimulation relation on colonies. We also present some decidability results for particular cases of robustness.

The satisfiability problems for and are known to be EXPTIME-complete, resp. 2EXPTIME-complete (Fischer and Ladner (1979), Vardi and Stockmeyer (1985)). For fragments that use less temporal or propositional operators, the complexity may decrease. This paper undertakes a systematic study of satisfiability for -and -formulae over restricted sets of propositional and temporal operators. We show that restricting the temporal operators yields satisfiability problems complete for 2EXPTIME, EXPTIME, PSPACE, and NP. Restricting the propositional operators either does not change the complexity (as determined by the temporal operators), or yields very low complexity like NC¹, TC⁰, or NLOGTIME.

The satisfiability problem of the branching time logic CTL is studied in terms of computational complexity. Tight upper and lower bounds are provided for each temporal operator fragment. In parallel, the minimal model size is studied with a suitable notion of minimality. Thirdly, flat CTL is investigated, i.e., formulas with very low temporal operator nesting depth. A sharp dichotomy is shown in terms of complexity and minimal models: Temporal depth one has low expressive power, while temporal depth two is equivalent to full CTL.

We introduce a weighted linear dynamic logic (weighted LDL for short) and show the expressive equivalence of its formulas to weighted rational expressions. This adds a new characterization for recognizable series to the fundamental Schützenberger theorem. Surprisingly, the equivalence does not require any restriction to our weighted LDL. Our results hold over arbitrary (resp. totally complete) semirings for finite (resp. infinite) words. As a consequence, the equivalence problem for weighted LDL formulas over fields is decidable in doubly exponential time. In contrast to classical logics, we show that our weighted LDL is expressively incomparable to weighted LTL for finite words. We determine a fragment of the weighted LTL such that series over finite and infinite words definable by LTL formulas in this fragment are definable also by weighted LDL formulas. This is an extended version of [17].

We introduce a class of distributed systems called Communicating Sequential Agents (CSAs). Sound and complete axiomatizations are provided for various subclasses using a family of indexed temporal logics. Some of the important features of these logics are:

• Both the formulas and the structures for the logics reflect the fact that a system is composed out of a number of participating sequential agents.

• Formulas of the logics are interpreted only at local states.

• An agent makes a definite assertion about another agent only if it has received — directly or indirectly — some communication from that agent supporting that assertion.

We introduce four classes of Z-regular grammars for generating bi-infinite words (i.e. Z-words) and prove that they generate exactly Z-regular languages. We extend the second order monadic theory of one successor to the set of the integers (i.e. Z) and give some characterizations of this theory in terms of Z-regular grammars and Z-regular languages. We prove that this theory is decidable and equivalent to the weak theory. We also extend the linear temporal logic to Z-temporal logic and then prove that each Z-temporal formula is equivalent to a first order monadic formula. We prove that the correctness problem for finite state processes is decidable.

We propose a description and validation of the ATMR protocol within the UNITY formalism. This formal description helps us understand precisely the mechanisms this protocol involves. In particular, we have noted the use of an incorrect detection algorithm to generate reset slots. In this first part, we provide an operational description using the UNITY programming notation as well as a specification of the main correctness properties in the UNITY temporal logic. A second part [2] is dedicated to a hand-made correctness proof. The proof shows that the model satisfies the specification despite this spurious detection. In this study, we apply a general development process based upon the UNITY formalism. During this process, we tune the program specification in order to make the later validation step easier, in the same way as the inclusion of traces, breakpoints, and assertions prepares a program for its quality assurance tests.

We propose a description and validation of the ATMR protocol within the UNITY formalism. This formal description helps us understand precisely the mechanisms this protocol involves. In particular, we have noted the use of an incorrect detection algorithm to generate reset slots. An operational description using the UNITY programming notation and a specification of the main correctness properties in the UNITY temporal logic are given in a previous part [2]. This second part is dedicated to a hand-made correctness proof. The proof shows that the model satisfies the specification despite the spurious detection in the reset generation mechanism.

In this paper, we introduce an observation relation as an abstraction of point-to-point communication in distributed architectures. After showing how its semantics and syntax can be embedded within the UNITY approach, we state general observation properties. Finally, we consider the description and the validation of a distributed mutual exclusion algorithm. The relevant aspect of such a validation is the exclusive use of refinements and observations properties for the proof of these refinements.

In a recent book, the author presented a mathematical specification of a blackboard system shell. The exercise suggested a method for developing blackboard systems with the aid of formal methods. This paper describes a formal method for the development of blackboard systems. The method is based, in part, on an informal one. Apart from the difference in emphasis (formal rather than informal), the new approach rests upon a formal definition of the architecture. The essential idea is that the mapping between the formal model of the problem domain (which is intended to be similar to the formal models proposed by, for example, Hayes) and the blackboard shell should be supported by formal proofs of correctness in a way identical to formal software engineering.

We present an informal method for constructing blackboard systems. The informal method forms the basis of the formal method whose initial stages are then described. We outline the formal treatment of control and suggest the use of temporal logic as a tool for reasoning about control. The paper ends with a review of the method.

Software architecture has become one of the most active research topics in software engineering in recent years. One of the distinct features of software architecture research is to explicitly study the interconnections (connectors) among system components. In this paper, we show how to formally specify several well-known general connectors in a software architecture methodology called SAM. Related work is discussed and compared. Our results establish the basis for reusing these defined connectors and for building more sophisticated connectors from them.

Software systems have evolved from monolithic programs to systems constructed from parallel, cooperative components, as can be currently found in object-oriented applications. Although powerful, these cooperative systems are also more difficult to verify.

We show that it is possible to automatically translate a PARADIGM specification to a Propositional Linear Temporal Logic based program. This has several interesting consequences: a) on one hand we allow a more declarative view of PARADIGM specifications, b) the resulting translation is an executable specification and c) as we show in this work it can also be used to verify correctness properties by automatic means. We think this will contribute to enhance the understanding, usability and further development of PARADIGM, and related methods like SOCCA, within both the Software Engineering and the Knowledge Engineering communities.

Prospec is a tool that assists practitioners in the elicitation and specification of system properties. Practitioners are guided by questions, definitions, and graphics. Prospec introduces the use of composite propositions to identify intended behavior when multiple conditions or events are considered. Multiple conditions or events may represent behavior such as sequences, concurrency, and non-determinism and may define the boundaries of scopes or type of patterns. Prospec is built upon the Specification Pattern System. The tool assists the analyst in making informed decisions about aspects of a specification that may have multiple interpretations. The end product of the tool is a formal specification in Future Interval Logic, Linear Temporal Logic, or Meta Event Definition Language.

System assembly is one of the major issues in engineering complex component-based systems. This is especially true when heterogeneous, COTS and GOTS distributed systems, typical in industrial applications, are involved. The goal of system assembly is not only to make constituent components work together, but also to ensure that the components as a whole behave consistently and guarantee certain end-to-end properties. Despite recent advances, there is a lack of understanding about software composability, as well as theory and techniques for checking and verifying component-based systems. A theory of software system constraints about components, their environment and about system as a whole is the necessary foundation toward solid understanding of the composability of component-based systems. In this paper, we present a systematic approach for constraint specification and constraint propagation in concert with design refinement with a novel technique to ensure consistency between system-wide and component constraints in a design composition process of component-based systems. The consistent constraint propagation is used in our approach to drive progressive verification of the design. It allows us to verify overall design composition without interference of internal details of component designs. Verification is done separately at architectural and component levels without having to compose results of component analyses. A component can be safely replaced with alternative design without re-verifying the overall system composition so long as the replacement conforms to the corresponding interface and component constraint(s).

This paper presents an approach to support run-time verification of software systems that combines two existing tools, Prospec and Java-MaC, into a single framework. Prospec can be used to clarify natural language specifications for sequential, concurrent, and nondeterministic behavior. In addition, Prospec assists the user in reading, writing, and understanding formal specifications through the use of property patterns and visual abstractions. Prospec automatically generates specifications written in Future Interval Logic (FIL). Java-MaC monitors Java programs at runtime to ensure adherence to a set of formally specified properties. Safety properties of a program are specified in the formal language Meta-Event Definition Language (MEDL). Java-MaC generates runtime components from specifications. The components are used to instrument the target program and determine whether the execution of the program violates any of the safety properties. This paper describes an algorithm for translating FIL formulas into MEDL formulas. It provides the transformation rules used by this algorithm, and it demonstrates the general correctness of the translation.