Compositional Proof System Research Articles

The Extension of Semantic Formalization of Service Workflow Specification Language

Service-Oriented Computing (SOC) is changing the way modern information systems that are designed, operated, and evolved. SOC makes possible to aggregate distributed resources at the phases of decision-making support and system operations. When myriads of resources with similar functionalities are available, effective methodologies are demanded to select services and compose them as service workflows for the specified goals. The computation for workflow composition is very complex since it depends on the numbers of services and their dynamic characteristics. Therefore, composing optimized workflows in a timely manner poses a great challenge. We are highly motivated to reduce the complexity of service selection and composition. The formalized semantics in SWSpec is extended so that unqualified or inferior services can be eliminated directly from the scope of the design solution space. In this paper, a brief review of the proposed SWSpec language is given and the focus is on the sematic formalization. A new compositional proof-system is developed with a set of inference rules and the proven system properties. The proposed semantic formalization has its great significance in reducing the complexity of composing workflows and developing efficient algorithms for compliance checking.

Compositional reasoning about active objects with shared futures

Abstract Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. The future mechanism extends the traditional method call communication model by facilitating sharing of references to futures. By assigning method call result values to futures, third party objects may pick up these values. This may reduce the time spent waiting for replies in a distributed environment. However, futures add a level of complexity to program analysis, as the program semantics becomes more involved. This paper presents a model for asynchronously communicating objects, where return values from method calls are handled by futures. The model facilitates invariant specifications over the locally visible communication history of each object. Compositional reasoning is supported and proved sound, as each object may be specified and verified independently of its environment. A kernel object-oriented language with futures inspired by the ABS modeling language is considered. A compositional proof system for this language is presented, formulated within dynamic logic.

The ramifications of sharing in data structures

Programs manipulating mutable data structures with intrinsic sharing present a challenge for modular verification. Deep aliasing inside data structures dramatically complicates reasoning in isolation over parts of these objects because changes to one part of the structure (say, the left child of a dag node) can affect other parts (the right child or some of its descendants) that may point into it. The result is that finding intuitive and compositional proofs of correctness is usually a struggle. We propose a compositional proof system that enables local reasoning in the presence of sharing. While the AI "frame problem" elegantly captures the reasoning required to verify programs without sharing, we contend that natural reasoning about programs with sharing instead requires an answer to a different and more challenging AI problem, the "ramification problem": reasoning about the indirect consequences of actions. Accordingly, we present a RAMIFY proof rule that attacks the ramification problem head-on and show how to reason with it. Our framework is valid in any separation logic and permits sound compositional and local reasoning in the context of both specified and unspecified sharing. We verify the correctness of a number of examples, including programs that manipulate dags, graphs, and overlaid data structures in nontrivial ways.

Observable Behavior of Dynamic Systems: Component Reasoning for Concurrent Objects

Current object-oriented approaches to distributed programs may be criticized in several respects. First, method calls are generally synchronous, which leads to much waiting in distributed and unstable networks. Second, the common model of thread concurrency makes reasoning about program behavior very challenging. Models based on concurrent objects communicating by asynchronous method calls, have been proposed to combine object orientation and distribution in a more satisfactory way. In this paper, a high-level language and proof system are developed for such a model, emphasizing simplicity and modularity. In particular, the proof system is used to derive external specifications of observable behavior for objects, encapsulating their state. A simple and compositional proof system is paramount to allow verification of real programs. The proposed proof rules are derived from the Hoare rules of a standard sequential language by a semantic encoding preserving soundness and relative completeness. Thus, the paper demonstrates that these models not only address the first criticism above, but also the second.

From process logic to program logic

We present a process logic for the p -calculus with the linear/affine type discipline [6, 7, 31, 32, 33, 59, 60]. Built on the preceding studies on logics for programs and processes, simple systems of assertions are developed, capturing the classes of behaviours ranging from purely functional interactions to those with destructive update, local state and genericity. A central feature of the logic is representation of the behaviour of an environment as the dual of that of a process in an assertion, which is crucial for obtaining compositional proof systems. From the process logic we can derive compositional program logics for various higher-order programming languages, whose soundness is proved via their embeddings into the process logic. In this paper, the key technical framework of the process logic and its applications is presented focussing on pure functional behaviour and a prototypical call-by-value functional language, leaving the full technical development to [27, 26].

Compositional Verification of Quantitative Properties of Statecharts

In this paper we propose a process language JSP which abstractly models timed statecharts with minimal and maximal delays associated to transitions. Statecharts processes are equipped with a labelled transition system semantics that combines the basic principles of the semantics of Pnueli and Shalev with discrete time. Furthermore, we propose a compositional proof system to check quantitative temporal properties of statecharts processes. Properties are expressed in a discrete extension of µ‐calculus with reset over clocks and clock constraints. The proof system is sound in general and it is complete for the class of regular processes (including processes corresponding to statecharts).

A compositional μ-calculus proof system for statecharts processes

In this paper we propose a quite general process language called ℘, which can be suitably instantiated to model the synchronous language statecharts. The main novelty of the language is an operator of process refinement for representing statecharts hierarchy. Moreover, we define a compositional proof system for checking μ-calculus properties of ℘ processes. Such a proof system is sound in general and it is complete for finite-state processes including the one corresponding to statecharts.

Proving Properties of Dynamic Process Networks

We present the first compositional proof system for checking processes against formulas in the modalμ-calculus which is capable of handling dynamic process networks. The proof system is obtained in a systematic way from the operational semantics of the underlying process algebra. A non-trivial proof example is given, and the proof system is shown to be sound in general, and complete for finite-state processes.

Proving concurrent constraint programs correct

We introduce a simple compositional proof system for proving (partial) correctness of concurrent constraint programs (CCP). The proof system is based on a denotational approximation of the strongest postcondition semantics of CCP programs. The proof system is proved to be correct for full CCP and complete for the class of programs in which the denotational semantics characterizes exactly the strongest postcondition. This class includes the so-called confluent CCP, a special case of which is constraint logic programming with dynamic scheduling.

On using temporal logic for refinement and compositional verification of concurrent systems

A simple and elegant formulation of compositional proof systems for concurrent programs results from a refinement of temporal logic semantics. The refined temporal language we propose is closed under w-stuttering and, thus, provides a fully abstract semantics with respect to some chosen observation level w. This avoids incorporating irrelevant detail in the temporal semantics of parallel programs. Besides compositional verification, concurrent program design and implementation of a coarser-grained program by a finer-grained one, are easily practicable in the setting of the new temporal logic.

A brief history of Timed CSP

This paper is a comprehensive introduction to the language of Timed CSP, proposed by Reed and Roscoe (1986). A brief description of the notation is followed by a detailed survey of timed and untimed models for the language. A compositional proof system is included, together with an account of timed refinement. The paper ends with a list of the changes made to the theory in recent years, and a brief discussion of other timed process algebras.

Extending hoare logic to real-time

Abstract Classical Hoare triples are modified to specify and design distributed real-time systems. The assertion language is extended with primitives to express the timing of observable actions. Further the interpretation of triples is adapted such that both terminating and nonterminating computations can be specified. To verify that a concurrent program, with message passing along asynchronous channels, satisfies a real-time specification, we formulate a compositional proof system for our extended Hoare logic. The use of compositionality during top-down design is illustrated by a process control example of a chemical batch processing system.

Program composition via unification

Program composition and compositional proof systems have proved thermselves important for simplifying the design and the verification of programs. The paper presents a version of the jigsaw program composition operator previously defined in [Fix et al. (1991, 1992)]. Here, the jigsaw operator is defined as the unification of its components by their most general unifier. The jigsaw operator generalizes and unifies the traditional sequential and parallel program composition operators and the newly proposed union and superposition operators. We consider a family of frameworks each consisting of a programming language, a specification language and a compositional syntax-directed proof system. We present syntactic rules to augment any given framework in the family with the jigsaw operator. The augmented framework is syntax-directed and compositional. Moreover, it is sound and complete with respect to the given framework.

A Resource-Based Prioritized Bisimulation for Real-Time Systems

The behavior of concurrent, real-time systems can be specified using a process algebra called CCSR. The underlying computation model of CCSR is a resource-based one in which multiple resources execute synchronously, while processes assigned to the same resource are interleaved according to their priorities. CCSR allows the algebraic specification of timeouts, interrupts, periodic behaviors, and exceptions. This paper develops a natural treatment of preemption, which is based not only on priority, but also on resource utilization and inter-resource synchronization. The preemption ordering leads to a term equivalence based on strong bisimulation, which is also a congruence with respect to the operators. Consequently the equivalence yields a compositional proof system, which is illustrated in the verification of a resource-sharing, producer-consumer problem.

Compositional verification of a distributed real-time arbitration protocol

A distributed real-time arbitration protocol is specified and verified using an assertional method. The formalism is based on classical Hoare triples which have been extended to deal with real-time properties. To verify design steps, a compositional proof system has been formulated for these extended triples. The intention of the protocol is to resolve contention between a number of concurrent modules that compete to acquire control of a common bus. Therefore our proof method has been adapted to deal with concurrent processes that communicate by means of a common bus. Compositionality makes it possible to verify the required properties of the protocol using only the specifications of the modules. Next we give a top-down derivation of a program implementing a module according to its real-time specification.

Top-Down Design of Embedded Real-Time AI Systems

A formal method is proposed for the specification and verification of embedded real-time systems. We consider distributed systems in which parallel processes communicate by sending messages along synchronous or asynchronous channels. To verify that a program satisfies a specification, a compositional proof system is given. Compositionality enables verification during the process of top-down program design. This is illustrated by an example of a rail road crossing. Starting from an assertional specification, we design a program that controls lamps and barriers using information from sensors that signal the passage of trains at a certain distance from the crossing.

Top-down design of embedded real-time AI systems

A formal method is proposed for the specification and verification of embedded real-time systems. We consider distributed systems in which parallel processes communicate by sending messages along synchronous or asynchronous channels. To verify that a program satisfies a specification, a compositional proof system is given. Compositionality enables verification during the process of top-down program design. This is illustrated by an example of a rail road crossing. Starting from an assertional specification, we design a program that controls lamps and barriers using information from sensors that signal the passage of trains at a certain distance from the crossing.

P — A logic — a compositional proof system for distributed programs

This paper describes a compositional proof system called P-A logic for establishing weak total correctness and weak divergence correctness of CSP-like distributed programs with synchronous and asynchronous communication. Each process in a network is specified using logical assertions in terms of a presupposition Pre and an affirmation Aff as a triple {Pre}S{Aff}. For purely sequential programs, these triples reduce to the familiar Hoare triples. In distributed programs, P-A triples allow the behaviour of a process to be specified in the context of assumptions about its communications with the other processes in the network. Safety properties of process communications, and progress properties such as finiteness and freedom from divergence can be proved. An extension of P-A logic allowing proof of deadlock freedom is outlined. Finally, proof rules for deriving some liveness properties of a program from its P-A logic specification are discussed; these properties have the form "Q until R", where Q, R are assertions over communication traces. Other liveness properties may be derived from these properties using the rules of temporal logic.

Compositionality in the temporal logic of concurrent systems (extended abstract)

In this paper we develop a new method for describing in temporal logic in a compositional manner sequential composition, its iterated version (loops) and its interaction with (nested) parallelism. The logic we will use will be a linear time logic with as sole temporal operator the until. We will illustrate this method in the construction of a compositional proof system for a CSP-like language. We will prove this system to be sound and (relative) complete.

A compositional proof system on a category of labelled transition systems

This paper presents an attempt to cast labelled transition systems, and other models of parallel computation, in a category-theoretic framework. One aim is to use category theory to provide abstract characterisations of constructions like parallel composition valid throughout a range of different models and to provide formal means for translating between different models. Another aim is to exploit the framework of categorical logic to systematise specification languages and the derivation of proof systems for parallel processes. After a category of labelled transition systems is presented, its categorical constructions are used to establish a compositional proof system. A category of properties of transition systems indexed by the category of labelled transition systems is used in forming the proof system.