In this paper we describe the promoted tyft/tyxt rule format for defining higher-order languages. The rule format is a generalization of Groote and Vaandrager 's tyft/tyxt format in which terms are allowed as labels on transitions in rules. We prove that bisimulation is a congruence for any language defined in promoted tyft/tyxt format and demonstrate the usefulness of the rule format by presenting promoted tyft/tyxt definitions for the lazy -calculus, CHOCS and the ß-calculus. 1 Introduction For a programming language definition that uses bisimulation as the notion of equivalence, it is desirable for the bisimulation relation to be compatible with the language constructs; i.e. that bisimulation be a congruence. Several rule formats have been defined, so that as long as a definition satisfies certain syntactic constraints, then the defined bisimulation relation is guaranteed to be a congruence. However these rule formats have not been widely used for defining languages with higher-...

Abstract not found

The operational behavior of interactive systems is usually given in terms of transition systems labeled with actions, which, when visible, represent both observations and interactions with the external world. The abstract semantics is given in terms of behavioral equivalences, which depend on the action labels and on the amount of branching structure considered. Behavioural equivalences are often congruences with respect to the operations of the language, and this property expresses the compositionality of the abstract semantics. A simpler approach, inspired by classical formalisms like λ-calculus, Petri nets, term and graph rewriting, and pioneered by the Chemical Abstract Machine [1], defines operational semantics by means of structural axioms and reaction rules. Process calculi representing complex systems, in particular those able to generate and communicate names, are often defined in this way, since structural axioms give a clear idea of the intended structure of the states while reaction rules, which are often non-conditional, give a direct account of the possible steps. Transitions caused by reaction rules, however, are not labeled, since

We explore an algebraic language for networks consisting of a fixed number of reactive units, communicating synchronously over a fixed linking structure. The language has only two operators: disjoint parallelism, where two networks are composed in parallel without any interconnections, and linking, where an interconnection is formed between two ports. The intention is that these operators correspond to the primitive steps when constructing networks, and that they therefore are conceptually simpler than the operators in existing process algebras. We investigate the expressive power of our language. The results are: (1) Definability of behaviours: with only three simple processing units, every finite-state behaviour can be constructed. (2) Definability of operators: we characterise the network operators which are definable within the language," these turn out to include most operators previously suggested for describing parallelism. Our results hold for any congruence between trace equivalence and observation equivalence.

Abstract. We propose an extension of concurrent constraint programming with primitives for process migration within a hierarchical network, and we study its semantics. To this purpose, we first investigate a “pure ” paradigm for process migration, namely a paradigm where the only actions are those dealing with transmissions of processes. Our goal is to give a structural definition of the semantics of migration; namely, we want to describe the behaviour of the system, during the transmission of a process, in terms of the behaviour of the components. We achieve this goal by using a labeled transition system where the effects of sending a process, and requesting a process, are modeled by symmetric rules (similar to handshaking-rules for synchronous communication) between the two partner nodes in the network. Next, we extend our paradigm with the primitives of concurrent constraint programming, and we show how to enrich the semantics to cope with the notions of environment and constraint store. Finally, we show how the operational semantics can be used to define an interpreter for the basic calculus. 1

Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.2.2 Inductive Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.2.3 Rule-Based Inductive Denitions . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.2.4 Dening the Transition Relation . . . . . . . . . . . . . . . . . . . . . . . . . 8 2.2.5 Building Labeled Transition Systems . . . . . . . . . . . . . . . . . . . . . . . 8 2.3 Retargeting the CWB-NC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.4 PAC Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.5 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 3 PAC Syntax Specications 13 3.1 PAC Identiers and Keywords. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.2 Structure of the Syntactic Description . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.3 Abstract Syntax . . . . . . . . . . . ...

A recursive program is determined, up to bisimilarity, by the operation of the recursion body on arbitrary processes, of which it is a fixpoint. The traditional proof of this fact uses Howe’s method, but that does not tell us how the fixpoint is obtained. In this paper, we show that the fixpoint may be obtained by a least fixpoint procedure iterated through the hierarchy of countable ordinals, using Groote and Vaandrager’s notion of nested simulation. 1