A general approach is proposed for transforming objects to methods on the fly in the framework of the π-calculus. The power of the approach is demonstrated by applying it to generate an encoding of the full lambda calculus in the π-calculus. The encoding is proved to preserve and reflect beta reduction, and is shown to be fully abstract with respect to Abramsky's applicative bisimilarity.

Harvey Friedman’s gap condition on embeddings of finite labelled trees plays an important role in combinatorics (proof of the graph minor theorem) and mathematical logic (strong independence results). In the present paper we show that the gap condition can be reconstructed from a small number of well-motivated building blocks: It arises via iterated applications of a uniform Kruskal theorem.

In this paper, we consider a discrete-time quantum walk on the N-cycle governed by the condition that at every time step of the walk, the option persists, with probability p, of exercising a projective measurement on the coin degree of freedom. For a bipartite quantum system of this kind, we prove that the von Neumann entropy of the total density operator converges to its maximum value. Thus, when influenced by decoherence, the mutual information between the two subsystems corresponding to the space of the coin and the space of the walker must eventually diminish to zero. Put plainly, any level of decoherence greater than zero forces the system to become completely ‘disentangled’ eventually.

In this paper, we develop a general framework for continuous data representations using positive predicate structures. We first show that basic principles of Σ-definability which are used to investigate computability, i.e., existence of a universal Σ-predicate and an algorithmic characterization of Σ-definability hold on all predicate structures without equality. Then we introduce positive predicate structures and show connections between these structures and effectively enumerable topological spaces. These links allow us to study computability over continuous data using logical and topological tools.

We present a formalisation in Agda of the theory of concurrent transitions, residuation and causal equivalence of traces for the π-calculus. Our formalisation employs de Bruijn indices and dependently typed syntax, and aligns the ‘proved transitions’ proposed by Boudol and Castellani in the context of CCS with the proof terms naturally present in Agda's representation of the labelled transition relation. Our main contributions are proofs of the ‘diamond lemma’ for the residuals of concurrent transitions and a formal definition of equivalence of traces up to permutation of transitions.

In the π-calculus, transitions represent propagating binders whenever their actions involve bound names. To accommodate these cases, we require a more general diamond lemma where the target states of equivalent traces are no longer identical, but are related by a braiding that rewires the bound and free names to reflect the particular interleaving of events involving binders. Our approach may be useful for modelling concurrency in other languages where transitions carry meta-data sensitive to particular interleavings, such as dynamically allocated memory addresses.

In this note we show that quotients of countably based spaces (qcb spaces) and topological predomains, as introduced by M. Schröder and A. Simpson, are not closed under sobrification. As a consequence, replete topological predomains need not be sober, that is, in general, repletion is not given by sobrification. Our counterexample also shows that a certain tentative ‘equaliser construction’ of repletion fails for qcb spaces.

Our results also extend to the more general class of core compactly generated spaces.

Nowadays concepts, languages and models for coordination cannot leave aside the needs of the increasing number of commercial applications based on global computing over the (inter)net. For example, platforms like Microsoft .NET and Sun Microsystems Java come equipped with packages for supporting ad hoc transactional features, which are essential for most business applications. We show how to extend the coordination language par excellence (viz. Linda) with basic primitives for transactions, while retaining a formal model for its concurrent computations. This is achieved by exploiting a variation of Petri nets, called zero-safe nets, where transactions can be suitably modelled by distinguishing between stable places (ordinary ones) and zero places (where tokens can only be temporarily allocated, defining hidden states). The relevance of the transaction mechanism is illustrated in terms of expressive power. Finally, it is shown that stable places and transactions viewed as atomic steps define an abstract semantics that is apt for a fully algebraic treatment, as demonstrated via categorical adjunctions between suitable categories of nets.

Discretionary Access Control (DAC) systems provide powerful resource management mechanisms based on the selective distribution of capabilities to selected classes of principals. We study a type-based theory of DAC models for a process calculus that extends Cardelli, Ghelli and Gordon's pi-calculus with groups (Cardelli et al. 2005). In our theory, groups play the role of principals and form the unit of abstraction for our access control policies, and types allow the specification of fine-grained access control policies to govern the transmission of names, bound the (iterated) re-transmission of capabilities and predicate their use on the inability to pass them to third parties. The type system relies on subtyping to achieve a selective distribution of capabilities to the groups that control the communication channels. We show that the typing and subtyping relationships of the calculus are decidable. We also prove a type safety result, showing that in well-typed processes all names:

1. (i) flow according to the access control policies specified by their types; and

2. (ii) are received at the intended sites with the intended capabilities.

Graph transitions represent an extension of the DPO approach to graph transformation for the specification of reactive systems. In this paper, we develop the theory of concurrency for graph transitions. In particular, we prove a local Church–Rosser theorem and define a notion of shift-equivalence that allows us to represent both intra-concurrency (within the specified subsystem) and inter-concurrency (between subsystem and environment). Via an implementation of transitions in terms of DPO transformations with context rules, a second, more restrictive notion of equivalence is defined that captures, in addition, the extra-concurrency (between operations of the environment). As a running example and motivation, we show how the concepts of this paper provide a formal model for distributed information systems.

Domain-theoretic categories are axiomatised by means of categorical non-order-theoretic requirements on a cartesian closed category equipped with a commutative monad. In this paper we prove an enrichment theorem showing that every axiomatic domain-theoretic category can be endowed with an intensional notion of approximation, the path relation, with respect to which the category Cpo-enriches.

Our analysis suggests more liberal notions of domains. In particular, we present a category where the path order is not ω-complete, but in which the constructions of domain theory (such as, for example, the existence of uniform fixed-point operators and the solution of domain equations) are available.

This paper details a partial order semantics for families of scenarios represented by High-Level Message Sequence Charts (HMSCs): graph grammars generating event structures are used to represent HMSCs. A decision procedure for HMSC equivalence is then described. This can be considered as a first step towards the formal manipulation of scenarios.

We give a decision procedure for the extensional equality of total Böhm trees presented by regular systems of recursion equations.

We show that for every term graph in a left-linear but non-orthogonal term graph rewrite system, one can construct an event structure that represents all the possible reductions that can occur in reduction sequences starting from that term graph. Every finite reduction sequence from that graph corresponds to a configuration of the event structure, and Lévy-equivalent sequences correspond to the same configuration.

Garbage collection is modelled in the event structure by an ‘erases’ relation. The asymmetric conflicts that arise in non-orthogonal rewrite systems are modelled by introducing a ‘prevents’ relation. The configurations of the event structure then form the state space of an event automaton. Taking the directed completion of this space yields a prime algebraic domain.

We give a simple term calculus for the multiplicative exponential fragment of Classical Linear Logic, by extending Barber and Plotkin's dual-context system for the intuitionistic case. The calculus has the non-linear and linear implications as the basic constructs, and this design choice allows a technically manageable axiomatisation without commuting conversions. Despite this simplicity, the calculus is shown to be sound and complete for category-theoretic models given by *-autonomous categories with linear exponential comonads.

Bernstein coefficients provide a discrete approximation of the behaviour of a polynomial inside an interval. This can be used, for example, to isolate the real roots of polynomials. We prove formally a criterion for the existence of a single root in an interval and the correctness of the de Casteljau algorithm for computing Bernstein coefficients efficiently.

We define a categorical framework, based on the notion of sketch, for specification and evaluation in the senses of algebraic specifications and algebraic programming. This framework goes far beyond our initial motivation, which was to specify computation with algebraic numbers. We begin by redefining sketches in order to deal explicitly with programs. Expressions and terms are carefully defined and studied, then quasi-projective sketches are introduced. We describe static evaluation in these sketches: we propose a rigorous basis for evalution in the corresponding structures. These structures admit an initial model, but are not necessarily equational. In Part II (Duval and Reynaud 1994), we study a more general process, called dynamic evaluation, for structures that may have no initial model.

We discuss quantum algorithms based on the Bernstein–Vazirani algorithm for finding which input variables a Boolean function depends on. There are 2n possible linear Boolean functions of n input variables; given a linear Boolean function, the Bernstein–Vazirani quantum algorithm can deterministically identify which one of these Boolean functions we are given using just one single function query. We show how the same quantum algorithm can also be used to learn which input variables any other type of Boolean function} depends on. The success probability of learning that the function depends on a particular input variable depends on} the form of the Boolean function that is tested, but does not depend on the total number of input variables. We also outline a procedure based on another quantum algorithm, the Grover search, to amplify further the success probability. Finally, we discuss quantum algorithms for learning the exact form of certain quadratic and cubic Boolean functions.

We use Gödel's dialectica interpretation to produce a computational version of the well-known proof of Ramsey's theorem by Erdős and Rado. Our proof makes use of the product of selection functions, which forms an intuitive alternative to Spector's bar recursion when interpreting proofs in analysis. This case study is another instance of the application of proof theoretic techniques in mathematics.

is an untyped continuation-style formal language with a typed subset that provides a Curry–Howard isomorphism for a sequent calculus for implicative classical logic. can also be viewed as a language for describing nets by composition of basic components connected by wires. These features make an expressive platform on which many different (applicative) programming paradigms can be mapped. In this paper we will present the syntax and reduction rules for ; in order to demonstrate its expressive power, we will show how elaborate calculi can be embedded, such as the λ-calculus, Bloo and Rose's calculus of explicit substitutions λx, Parigot's λμ and Curien and Herbelin's .

was first presented in Lengrand (2003), where it was called the λξ-calculus. It can be seen as the pure untyped computational content of the reduction system for the implicative classical sequent calculus of Urban (2000).

Triple graph grammars (TGGs) are a well-established concept for the specification and execution of bidirectional model transformations within model driven software engineering. Their main advantage is an automatic generation of operational rules for forward and backward model transformations, which simplifies specification and enhances usability as well as consistency. In this paper we present several important results for analysing model transformations based on the formal categorical foundation of TGGs within the framework of attributed graph transformation systems.

Our first main result shows that the crucial properties of correctness and completeness are ensured for model transformations. In order to analyse functional behaviour, we generate a new kind of operational rule, called a forward translation rule. We apply existing results for the analysis of local confluence for attributed graph transformation systems. As additional main results, we provide sufficient criteria for the verification of functional behaviour as well as a necessary and sufficient condition for strong functional behaviour. In fact, these conditions imply polynomial complexity for the execution of the model transformation. We also analyse information and complete information preservation of model transformations, that is, whether a source model can be reconstructed (uniquely) from the target model computed by the model transformation. We illustrate the results for the well-known model transformation example from class diagrams to relational database models.