Showing papers on "Process calculus published in 1987"

A Many-Sorted Calculus Based on Resolution and Paramodulation

Abstract: The first-order calculus whose well formed formulas are clauses and whose sole inference rules are factorization, resolution and paramodulation is extended to a many-sorted calculus. As a basis for Automated Theorem Proving, this many-sorted calculus leads to a remarkable reduction of the search space and also to simpler proofs. The soundness and completeness of the new calculus and the Sort-Theorem, which relates the many-sorted calculus to its one-sorted counterpart, are shown. In addition results about term rewriting and unification in a many-sorted calculus are obtained. Practical examples and a proof protocol of an automated theorem prover based on the many-sorted calculus are presented.

Another look at abstraction in process algebra

Abstract: Central to theories of concurrency is the notion of abstraction. Abstraction from internal actions is the most important tool for system verification. In this paper, we look at abstraction in the framework of the Algebra of Communicating Processes (see BERGSTRA & KLOP [4, 6]). We introduce a hidden step η, and construct a model for the resulting theory ACPη. We briefly look at recursive specifications in this theory, and discuss the relations with Milner's silent step τ.

Merge and termination in process algebra

Abstract: In VRANCKEN [14], the empty process ɛ was added to the Algebra of Communicating Processes of BERGSTRA & KLOP [3, 4]. Reconsidering the definition of the parallel composition operator merge, we found that it is preferable to explicitly state the termination option. This gives an extra summand in the defining equation of merge, using the auxiliary operator √ (tick). We find that tick can be defined in terms of the encapsulation operator ∂H. We give an operational and a denotational semantics for the resulting system ACP√, and prove that they are equal. We consider the Limit Rule, and prove it holds in our models.

Induction principles formalized in the calculus of constructions

Abstract: The Calculus of Constructions is a higher-order formalism for writing constructive proofs in a natural deduction style, inspired from work of de Bruijn [2,3], Girard [12], Martin-Lof[14] and Scott [18]. The calculus and its syntactic theory were presented in Coquand's thesis [7], and an implementation by the author was used to mechanically verify a substantial number of proofs demonstrating the power of expression of the formalism [9]. The Calculus of Constructions is proposed as a foundation for the design of programming environments where programs are developed consistently with formal specifications. The current paper shows how to define inductive concepts in the calculus.

Process algebra semantics for queues

Abstract: An unbounded queue over a finite set of data values, is a process Q in Aoo defined by an infinite system of guarded equations. The aim of this paper is to show that no finite system of guarded equations is capable of defining Q.

Conditional axioms and α/β calculus in process algebra

Abstract: During the last decade, various process models, or models for concurrency, have been proposed; we mention Milner's synchronisation trees in CCS (see [13]), the metrical process spaces of De Bakker and Zucker [4], the models based on preorders between processes of Hennessy and Plotkin [11] and the failure semantics of Brookes, Hoare and Roscoe [9] and Hoare [12]. (For more complete references we must refer to Bergstra and Klop [6].) Starting with Milner, there has been a growing interest in an algebraic treatment of concurrency. Here is our point of departure: rather than fixing a particular process model, we start with axioms describing a class of models. There are

Many-Sorted Resolution and Paramodulation

Abstract: This chapter discusses many-sorted resolution and paramodulation. Given a first-order calculus and its many-sorted version, the Sort Theorem tells that every truth that can be deduced in the many-sorted calculus can also be deduced in the unsorted system. There are theorems of the unsorted calculus that do not have many-sorted counterparts. This does not entail an incompleteness property of the many-sorted system, because these many-sorted nontheorems are meaningless. Both calculi are equivalent regarding soundness and completeness, and this is the reason why many-sorted logic has received scarce attention in the field of formal logic. The resolution calculus is a first-order calculus that has been proved to be useful and successful in automated theorem proving. This calculus was augmented with the paramodulation rule, an inference rule designed to implement equality reasoning efficiently. The outstanding features of the resolution calculus with paramodulation are its deduction incompleteness and the principle of most generality, which are the reasons for the efficiency of this calculus.

Program understanding with the lambda calculus

Abstract: A prerequisite of any attempt to build intelligent tools to assist in the programming process is a representation language for encoding programming knowledge. Languages that have been used for this purpose include the predicate calculus [5] and various program-schema languages [1,4]. This paper advocates a new candidate which is as expressive as the predicate calculus but more intimately connected w i th programming: the lambda calculus. Its advantages lie in its close resemblance to conventional programming languages, and in a straighforward model of inference by rewriting, which can be applied to automatic programming and program understanding. The use of the lambda calculus in an automatic program understander is described.

Modular specifications in process algebra

Abstract: In recent years a wide variety of process algebras has been proposed in the literature. Often these process algebras are closely related: they can be viewed as homomorphic images, submodels or restrictions of each other. The aim of this paper is to show how the semantical reality, consisting of a large number of closely related process algebras, can be reflected, and even used, on the level of algebraic specifications and in process verifications. This is done by means of the notion of a module. The simplest modules are building blocks of operators and axioms, each block describing a feature of concurrency in a certain semantical setting. These modules can then be combined by means of a union operator +, an export operator □, allowing to forget some operators in a module, an operator H, changing semantics by taking homomorphic images, and an operator S which takes subalgebras. These operators enable us to combine modules in a subtle way, when the direct combination would be inconsistent. We show how auxiliary process algebra operators can be hidden when this is needed. Moreover it is demonstrated how new process combinators can be defined in terms of the more elementary ones in a clean way. As an illustration of our approach, a methodology is presented that can be used to specify FIFO-queues, and that facilitates verification of concurrent systems containing these queues.

An algebraic specification of process algebra, including two examples

Abstract: A study is made of the possibilities to describe process algebra as an algebraic specification. Two examples from the field of the specification of communication protocols are discussed to analyse the adequacy of this approach in practical situations.

Extensions to communicating sequential processes to allow protocol performance specification

Abstract: Formalisms based on Hoare's Communicating Sequential Processes (CSP) and Milner's Calculus of Communicating Systems (CCS) for verifying protocols are currently being used by the International Standard Organisation (ISO). However, these models need to be extended if protocol performance specification and verification is to be done, as neither of these models have timing information (other than sequencing) nor a way of specifying controlled loss of information.This paper presents two extensions to Hoare's CSP that are felt by the author to provide suitable mechanisms for specifying protocol performance. Firstly, the effects of introducing time into CSP are presented, based on the work done by Reed and Roscoe. Secondly, the traces model is modified by associating probabilities with event sequences.Finally, some example specifications are given using these two extensions.

Programming language concepts—the Lambda calculus approach

Abstract: The Lambda Calculus is a formal system, originally intended as a tool in the foundation of mathematics, but mainly used to study the concepts of algorithm and effective computability. Recently, the Lambda Calculus and related systems acquire attention from Computer Science for another reason too: several important programming language concepts can be explained elegantly and can be studied successfully in the framework of the Lambda Calculi. We show this mainly by means of examples. We address ourselves to interested computer scientists who have no prior knowledge of the Lambda Calculus. The concepts discussed include: parameterization, definitions, recursion, elementary and composite data types, typing, abstract types, control of visibility and life-time, and modules.

Design based on a Calculus of Nets

Abstract: We present an algebraic approach to hierarchical design of integrated circuits. This approach is based on a “calculus of nets” which includes topological as well as behavioural aspects of integrated circuits. We have developed a hierarchical design system called CADIC which is build around this calculus in much the same way as e.g. Algol is build around numerics. An example for the design of a family of fast adders will demonstrate the power of this calculus. Finally we will give a summary outline on the structure of procedures which automatically transform the design into lower design levels.