Ruurd Kuiper

Now you may compose temporal logic specifications

A compositional temporal logic proof system for the specification and verification of concurrent programs is presented. Versions of the system are developed for shared variables and communication based programming languages that include procedures.

A really abstract concurrent model and its temporal logic

In this paper we advance the radical notion that a computational model based on the <i>reals</i> provides a more abstract description of concurrent and reactive systems, than the conventional <i>integers</i> based behavioral model of execution <i>sequences.</i> The real model is studied in the setting of temporal logic, and we illustrate its advantages by providing a <i>fully abstract</i> temporal semantics for a simple concurrent language, and an example of verification of a concurrent program within the real temporal logic defined here. It is shown that, by imposing the crucial condition of <i>finite variability,</i> we achieve a balanced formalism that is insensitive to <i>finite</i> stuttering, but can recognize <i>infinite</i> stuttering, a distinction which is essential for obtaining a fully abstract semantics of non-terminating processes. Among other advantages, going into real-based semantics obviates the need for the controversial representation of concurrency by interleaving, and most of the associated fairness constraints.

A Modal Approach to Intentions, Commitments and Obligations: Intention plus Commitment yields Obligation

In this paper we introduce some new operators that make it possible to reason about decisions and commitments to do actions. In our framework, a decision leads to an intention to do an action. The decision in itself does not change the state of the world; a commitment to actually perform the intended action changes the deontic state of the world such that the intended action becomes obligated. Of course, the obligated action may never actually occur. In our semantic structure, we use static (ough-to-be) and dynamic (ought-to-do) obligation operators. The static operator resembles the classical conception of obligation as truth in ideal worlds, except that it takes the current state as well as the past history of the world into account. This is necessary because it allows us to compare the way a state is actually reached with the way we committed ourselves to reach it. We show that some situations that could formerly not be expressed easily in deontic logic can be described in a natural way using the extended logic described in this paper.

Verification of Object Oriented Programs Using Class Invariants

A proof system is presented for the verification and derivation of object oriented programs with as main features strong typing, dynamic binding, and inheritance. The proof system is inspired on Meyers system of class invariants [12] and remedies its unsoundness, which is already recognized by Meyer. Dynamic binding is treated in a flexible way: when throughout the class hierarchy overriding methods respect the preand postconditions of the overridden methods, very simple proof rules for method calls suffice; more powerful proof rules are supplied for cases where one cannot or does not want to follow this restriction. The proof system is complete relative to proofs for properties of pointers and the data domain.

Combining dynamic deontic logic and temporal logic for the specification of deadlines

Intelligent agents have an agenda that is monitored continuously to decide what action is to be performed. Formally, an agenda is a set of deontic temporal constraints. Deontic, since the agenda specifies what the agent should do. Temporal, since the obligation is usually to be performed before a certain deadline, or as soon as possible. In this paper, we investigate the concepts necessary to describe deadlines. We describe a temporal deontic logic that facilitates reasoning about obligations and deadlines. The logic is a combination of temporal logic and deontic dynamic logic. We describe extensively which choices have to be made in combining temporal and dynamic aspects into one system. In the new logic, we can uniformally specify that an obligation starts at a certain time or event, that it must be done immediately, as soon as possible, before a deadline, or periodically.

Propositional Temporal Logics and Equivalences

We compare propositional temporal logics by comparing the equivalences that they induce on models. Linear time, branching time and partial order temporal logics are considered. The logics are interpreted on occurrence transition systems, generated by labelled prime event structures without autoconcurrency. The induced equivalences are also compared to directly defined equivalences, e.g., history preserving bisimulation, pomset bisimulation, pomset trace equivalence, and others. It is then shown which of the induced equivalences are and which are not preserved under action refinement.

Partial-order reduction techniques for real-time model checking

Abstract. A new notion, covering, generalising independence is introduced. It enables improved effects of partial-order reduction techniques when applied to real-time systems. Furthermore, we formulate a number of locally checkable conditions for covering that can be used as the basis for a practical algorithm. Correctness is proven with respect to a chosen discretisation method.

Invariants for Non-Hierarchical Object Structures

We present a Hoare-style specification and verification approach for invariants in sequential OO programs. It allows invariants over non-hierarchical object structures, in which update patterns that span several objects and methods occur frequently. This gives rise to invalidating and subsequent re-establishing of invariants in a way that compromises standard data induction, which assumes invariants hold when a method is called. We provide specification constructs (inc and coop) that identify objects and methods involved in such patterns, allowing a refined form of data induction. The approach now handles practical designs, as illustrated by a specification of the Observer Pattern.

Improving Partial Order Reductions for Universal Branching Time Properties

The ”state explosion problem” can be alleviated by using partial order reduction techniques. These methods rely on expanding only a fragment of the full state space of a program, which is sufficient for verifying the formulas of temporal logics LTL−X or CTL−X*(i.e., LTL or CTL* without the next state operator). This is guaranteed by preserving either a stuttering maximal trace equivalence or a stuttering bisimulation between the full and the reduced state space. Since a stuttering bisimulation is much more restrictive than a stuttering maximal trace equivalence, resulting in less powerful reductions for CTL−X*, we study here partial order reductions that preserve equivalences ”in-between”, in particular a stuttering simulation which is induced by the universal fragment of CTL:−X*, called ACTL−X* The reductions generated by our method preserve also branching simulation and weak simulation, but surprisingly, they do not appear to be included into the reductions obtained by Peleds method for verifying LTL−X properties. Therefore, in addition to ACTL−X* reduction method we suggest also an improvement of the LTL−X reduction method. Moreover, we prove that reduction for concurrency fair version of ACTL−X* is more efficient than for ACTL−X*.

Interface refinement in reactive systems

Suppose one has a system that has a synchronous interface with its environment. Now, suppose that one refines this system and changes its interface to an asynchronous one. Whatever is meant here by refinement, it cannot be standard (process) refinement since the interface actions have changed; nor is it action refinement in the sense that a process is substituted for an action, as the intention presumably is to allow the system to proceed without having to wait until the environment is willing to synchronize.