BRICS RS-96-38 H� uttel & Kleist: Objects as Mobile Processes

BRICS

Basic Research in Computer Science

Objects as Mobile Processes

Hans H� uttel Josva Kleist

BRICS Report Series RS-96-38 ISSN 0909-0878 October 1996 Copyright \begin{matrix}c \\ ◯ \end{matrix} 1996, BRICS, Department of Computer Science

University of Aarhus. All rights reserved.

Reproduction of all or part of this work is permitted for educational or research use on condition that this copyright notice is included in any copy.

See back inner page for a list of recent publications in the BRICS Report Series. Copies may be obtained by contacting:

BRICS Department of Computer Science University of Aarhus Ny Munkegade, building 540 DK - 8000 Aarhus C Denmark

Telephone: +45 8942 3360
Telefax: +45 8942 3255
Internet: BRICS@brics.dk

BRICS publications are in general accessible through World Wide Web and anonymous FTP:

http://www.brics.dk/
ftp://ftp.brics.dk/pub/BRICS

Objects as mobile processes

Hans Hüttel and Josva Kleist^{∗}

October 29, 1996

Abstract

The object calculus of Abadi and Cardelli [AC96, AC94b, AC94a] is intended as model of central aspects of object-oriented programming languages. In this paper we encode the object calculus in the asynchronous π-calculus without matching and investigate the properties of our encoding.

1 Introduction

In [AC96, AC94b, AC94a] Abadi and Cardelli investigate several versions of an object oriented calculus (the ς-calculus) with respect to its type system. The primary motivation behind the ς-calculus is to find a simple foundation for object oriented languages, just as the λ-calculus forms a foundation for functional programming languages.

In the ς-calculus the central concept is that of an object. Objects are built from object formation ([l_{i} = ς(x_{i})b_{i}]) where we create an object with methods l_{i} = ς(x_{i})b_{i}, method activation (a.l) where we activate the method named l in object a, and method override (a.l ⇐ ς(x)b) where the method named l in object a is exchanged with the new method l = ς(x)b. Despite its apparent simplicity, the ς-calculus has previously shown its ability to express several object oriented features within the calculus and it is also possible to encode the λ-calculus[Abr89].

In this paper we shall describe an encoding of the simplest version of the ς-calculus into an asynchronous version of the π-calculus[PW92] and investigate the properties of this encoding. In particular, the encoding is sound under the operational semantics of the ς-calculus. We also show that our encoding is not fully abstract with respect to weak bisimulation in the π-calculus and consider what constraints must be imposed on the π-calculus to get full abstractness. The work presented in this paper is thus related to the results achived by Sangiorgi in [San96] but arose independently. A main difference is in the choice of calculus; Sangiorgi employs the matching construct of the π-calculus, whereas the encoding presented in this paper does not and restricts its attention to the asynchronous π-calculus.

∗Address: Dep. of Computer Science, Aalborg University, Frederik Bajersvej 7, 9220 Aalborg, Denmark. Email: {hans,kleist}@cs.auc.dk

An encoding of the ς-calculus into the asynchronous π-calculus is interesting from several points of view. Firstly, most object oriented languages works with pointers, whereas the ς-calculus uses explicit substitution. In the π-calculus the basic entity is names that can be thought of as pointers; thus an encoding of the ς-calculus into the π-calculus shows how to use pointers to represent substitution. Secondly, the encoding presented in this paper also hints at the possibility of using a model checker for the π-calculus to verify properties of ς-calculus expressions. Thirdly, there is the implementation issue. When implementing programming languages on distributed systems, asynchronous communication is usually considered more easy to implement, so the encoding into an asynchronous calculus will also give an idea of how to implement the ς-calculus or a language based on the ς-calculus in a distributed setting. Finally, the π-calculus has also been put forward as a possible theoretical model of object-oriented programming languages, so an encoding will provide some basic insight into how one expresses object oriented features in the π-calculus.

The structure of the rest of the paper is as follows: Section 2 introduces the ς-calculus and explains its semantics. Section 3 gives the syntax and semantics of the asynchronous π-calculus that we shall use as our target calculus. In Section 4 we present our encoding of the ς-calculus into the asynchronous π-calculus and discuss alternative encodings. Section 5 and Section 6 regards operational correspondence of the encoding and relation between equivalences of ς-calculus terms and their encodings. Section 7 summarizes our results and relate them to other existing work.

2 The ς-calculus

The version of the ς-calculus we use is essentially the simple untyped object calculus of [AC96]. Objects in the ς-calculus are given by:

a ::= [l_{i} = ς(x_{i})b_{i}] objects
| x  self variables
| a.l  method activation
| a.l ⇐ ς(x)b method override

Here x_{i} ∈ SVar range over self variables and l_{i} ∈ MNames range over method names. We let m(a) denote the set of method names and fv(a) the set of free self variables in a.

We give the semantics for objects as a reduction semantics.

Let a = [l_{i} = ς(x_{i})b_{i}] with l_{i} ∈ L, then:

\begin{matrix}a.l_{k} & ⇝ & b_{k}\{^{a}/_{x_{k}}\} & l_{k} ∈ L \\ a.l ⇐ ς(x)b & ⇝ & [l_{i} = ς(x_{i})b_{i}, l = ς(x)b] & l_{i} ∈ L \ \{l\} \end{matrix}

The activation of the method l_{k} results in the method body being activated with the self variable being bound to the original object. Method override results in an object with the overridden method exchanged with the new method. In the original version of the ς-calculus it is not allowed to add methods to an object, a restriction introduced to keep the theory simple. Since the ability to add methods does not interfere with our encoding, we shall in the present paper allow addition of methods.

A context C[·] is an ‘incomplete’ ς-calculus term, and we write C[a] to denote that it has been completed using the term a. The syntax of contexts is given by:

C[·] ::= C[·].l | C[·].l ⇐ ς(x)b | [·]

Our final transition rule specifies the reduction strategy, which, given our syntax of contexts, implies leftmost reductions:

\frac{a ⇝ a′}{C[a] ⇝ C[a′]}

Leftmost reduction implies that we in a term a.l or a.l ⇐ ς(x)b always reduce a to an object before activating or overriding a method. That is, objects are the values of this version of the ς-calculus.

To give an intuition of how the ς-calculus works, we shall present a few simple examples (taken from [AC96])

let a = [l = ς(x)x.l]  then a.l ⇝ x.l{^{a}/_{x}} = a.l ⇝ ⋯
let a′ = [l = ς(x)x]  then a′.l ⇝ x{^{a′}/_{x}} = a′
let a′′ = [l = ς(y)y.l ⇐ ς(x)x] then a′′.l ⇝ a′′.l ⇐ ς(x)x ⇝ a′′

The object a shows how we can get infinite behaviour through the use of self variables. The object a′′ shows how an object can modify itself by performing a method override on a self variable.

3 The asynchronous π-calculus

The π-calculus [PW92] has previously shown its ability to encode both the λ-calculus [Mil92] and certain object oriented languages [Wal95, San96]. In [Wal95] Walker encoded a variant of the programming language POOL [Ame89] into the π-calculus and in [San96] Sangiorgi investigates another encoding of the ς-calculus into the π-calculus. Sangiorgi shows how to encode the ς-calculus in a type-correct way into an extended version of the π-cal-culus with a special case construct, which basically amounts to an extended matching operator.

As the target calculus for our translation we instead go for as simple a version of the π-calculus as possible. The version that we shall use is the asynchronous π-calculus [CS96, Bou92, HT91, HK95].

The syntax of asynchronous π-calculus is in the present paper given by:

P ::= āb̃ | P |P | (νã)P | G | !G G ::= 0 | a(b̃).P | τ.P | G + G

We let a, b, … ∈ Names range over an infinite c ountable set of names, b̃ denote tuples of names, a tuple of the names a, b and c will be written as ⟨a, b, c⟩. P ∈ Proc range over processes, G ∈ GProc range over guarded processes and Q ∈ Guard over guards. The use of guards ensures that we only replicate and sum guarded expressions.

We let bn(P), fn(P) and n(P), resp., denote the sest of bound names, free names and names of the agent P.

The difference between the synchronous and asynchronous π-calculus lies in the output construct. In the asynchronous π-calculus output is nonblocking, this is seen in the syntax as the absence of output prefixing (āb.P). Instead, output is modelled as the parallel composition of an output atom and the process (āb | P). The use of asynchronous communication has several advantages. Most importantly, several of the versions of bisimulation equivalence, that are distinct in the synchronous setting, coincide in an asynchronous setting. As a consequence, the algebraic theory becomes simpler [HK95, CS96].

For simplicity we shall only present the semantics of the monadic π-cal-culus, but it is easily extended to handle the polyadic case. The semantics is given by a labelled transition system with labels:

α ::= x̄y | x̄(y) | xy

x̄y denotes the output of the free name y on the name x. Transmission of bound names uses bound output x̄(y), indicating that we transmit the bound name y over the channel x. The last label xy denotes the input of the name y over the name x. Table 1 shows the inference rules for the asynchronous π-calculus, with the symmetric versions of [sync], [syncex], [comp] and [sum] omitted. We shall identify alpha-convertible terms, i.e. up to bound names.

[τ]  \frac{·}{τ.P \overline{}^{τ} P}  [ν]  \frac{P \overline{}^{α} P′ a ∉ n(α)}{(νa)P \overline{}^{α} (νa)P′}

[out] \frac{·}{āb \overline{}^{āb} 0}  [outex] \frac{P \overline{}^{āb} P′ a ≠ b}{(νb)P \overline{}^{ā(b)} P′}

[in] \frac{·}{a(b).P \overline{}^{ac} P \{c/b\}} [comp] \frac{P \overline{}^{α} P′ bn(α) ∩ fn(Q) = ∅}{P |Q \overline{}^{α} P′|Q}

[sum] \frac{G \overline{}^{α} P}{G + G′ \overline{}^{α} P}  [sync]  \frac{P \overline{}^{āb} P′ Q \overline{}^{ab} Q′}{P |Q \overline{}^{τ} P′|Q′}

[rep] \frac{G \overline{}^{α} P}{!G \overline{}^{α} P |!G}  [syncex] \frac{P \overline{}^{ā(b)} P′ Q \overline{}^{ab} Q′ b ∉ fn(Q)}{P |Q \overline{}^{τ} (νb)(P′|Q′)}

Table 1: The inference rules for the asynchronous π-calculus.

Just as in the synchronous π-calculus several definitions of bisimulation exist (see [CS96] for an overview). In the present paper we shall adopt the following definition, due to Amadio, Castellani and Sangiorgi [CS96]:

Definition 1 (Asynchronous bisimulation) A symmetric relation R is an asynchronous bisimulation if for all P R Q, whenever:

• P ^{\overline{}^{α}} P′ and α is not an input, then Q ^{\overline{}^{α}} Q′ and P′ R Q′.

• P ^{\overline{}^{ab}} P′ then either Q ^{\overline{}^{ab}} Q′ and P′ R Q′ or Q ^{\overline{}^{τ}} Q′ and

P′ R (Q′|āb).

We write P ∼ Q if P R Q for some asynchronous bisimulaton R.

The definition of asynchronous bisimulation is as the standard defintion for bisimulation except for the last part of the input case. This part expresses that if a process absorbs what it has just emitted, this can be “absorbed” in an internal action. A example of this (from [CS96]) is the following equational law:

a(b).(āb | P) + τ.P ∼ τ.P b ∉ fn(P)

Weak bisimulation (≈) is defined the usual way, by exchanging ^{\overline{}^{α}} in the above definition with the corresponding weak transition ⟹^{α}.

Our primary motivation for choosing the asynchronous π-calculus instead of the synchronous version is minimalism; we want to use as simple a version of the π-calculus as possible. But the choice gives us some important advantages. Most importantly, the notion of bisimilarity is unique and yields a congruence, a result that does not hold in the synchronous case or if we add matching. Also, the equational theory is simpler – in the synchronous case matching is needed to give an equational theory, whereas this is not necessary in the asynchronous π-calculus.

We use the notation P ^{\overline{}^{α}} _{d} Q to indicate that P ^{\overline{}^{α}} Q is the unique transition possible from P. To enhance readability we also omit the restrictions of names that no longer appear in a process, for instance, (νo)(x̄y) will be written as x̄y (formally, the two expressions are bisimlar).

4 Coding up the ς-calculus

The intuition behind our encoding is that the encoding of an object can be used via its value channel. More precisely, as soon as an object reduces to a value, an object reference is emitted on the value channel. An object reference is then used to activate methods by sending a value name, an object reference, and a method name to the object; the value name tells where we expect the result to be returned, the method name is the name of the method that we want to activate, the object reference that we pass is used if the called method wants to activate other methods. This is necessary in the case where a method has been overridden.

The polyadic π-calculus allows a straightforward typing discipline, called sorting, which ensures that suitable names are always communicated. Our encoding obeys the sorting:

Method names l : Method → (ObjRef)
Values  v : Value → (ObjRef)
Object references o : ObjRef → (Method, ObjRef, Value)
Self variables  x : Var

where v : Value → (ObjRef) expresses that v ranges over the set of value channels and we only transmit object references over value channels.

We assume that the sets of method names and self variables in the above sorting coincide with the set of method names and self variables in the ς-cal-culus.

4.1 The encoding

The encoding [[·]]_{v} presented below is parametrized with a value name v denoting the reference of the encoded object. The notation m(−).P denotes m(x).P for some name x ∉ fn(P).

[[a.l]]_{v} = (νv′)([[a]]_{v′} | v′(o).ō⟨l, o, v⟩)
[[[l_{i} = ς(x_{i})b_{i}]]]_{v} = (νo)(v̄o | !o(l′, o′, v′).(l̄′o′ | ∑ l_{i}(x_{i})[[b_{i}]]_{v′}))
[[x]]_{v} = v̄x
[[a.l ⇐ ς(x)b]]_{v} = (νv′)([[a]]_{v′} | v′(o).(νo′)(v̄o′ | !o′(l′′, o′′, v′′).

(l̄′′o′′ | l(x).[[b]]_{v′′} + ∑_{m∈m(a)\{l}} m(−).ō⟨l′′, o′′, v′′⟩)))

Observe that the above encoding prohibits free self variables, since the sorting prohibits the transmission of self variables over value names.

In the following we shall usually omit the index sets when they are obvious from the context.

4.2 Notational conventions

To enhance the readability of encoded terms, we shall in the following use the abbreviation:

o := [l_{i} = ς(x_{i})b_{i}] = !o(l′, o′, v′).(l̄′o′ | ∑ l_{i}(x_{i}).[[b_{i}]]_{v′})

The intuition behind this ‘relay’ construct o := [l_{i} = ς(x_{i})b_{i}] is that the object [l_{i} = ς(x_{i})b_{i}] resides at o. In other words, the object can have its methods activated by transmitting a method name, an object reference and a value name over the name o.

With this construct we can write the encoding [[[l_{i} = ς(x_{i})b_{i}]]]_{v} as (νo)(v̄o | o := [l_{i} = ς(x_{i})b_{i}]).

As can be seen from the encoding of method activation and override, we select the actual method to be invoked by means of communication over method names. This implies that the encoding might be messed up by πcalculus contexts that use method names incorrectly and cause erroneous transitions. For instance:

l(−) | [[[l = ς(x)x].l]]_{v}
= l(−) | (νv′)((νo)(v̄′o | o := [l = ς(x)x]) | v′o′.ō′⟨l, o′, v⟩)
\overline{}^{τ} l(−) | (νo)(o := [l = ς(x)x] | ō⟨l, o′, v⟩)

\overline{}^{τ} l(−) | newo(o := [l = ς(x)x] | l̄o | l(x).v̄x)
\overline{}^{τ} o := [l = ς(x)x] | l(x).v̄x

Observe how the input l(−) consumes the message that was intended for method selection. To avoid this, we implicitly assume that the method names are restricted at the outermost level in the encoding. Furthermore observe that the encoding does not mess up things, since we always wait for the output on a restricted name in the encoding (except when choosing methods).

We have already introduced the notation ^{\overline{}^{α}} _{d}, we shall extend this notation with transitions on the form P ^{\overline{}^{τ}} _{dl} Q indicating that the internal move from P to Q is the only possible transition except for actions on method names. And when we remember that the method names are restricted away at the outermost level and that our encoding does not create erroneous transitions, this implies that the transition is unique.

We use the notation a ⇑ to indicate that a has an infinite reduction sequence, and we write a ⇓ if a reduces to an object. In the π-calculus we use the same notation P ⇑ to indicate that P have an infinite sequence of τ-moves, and P ⇓ to indicate that P after a sequence of τ-moves will do an observable action.

4.3 Examples

To give the intuition of how the encoding works we shall consider a few examples.

Our first example is the encoding of the following simple object:

a = [l = ς(x)x.l]

It only contains one method l, that when activated will activate itself indefinitely, resulting in the infinite reduction sequence a.l ⇝ a.l ⇝ · · ·. In our encoding this corresponds to the following behaviour:

[[a.l]]_{v}
= (νv′)((νo)(v̄′o | o := [l = ς(x)x.l]) | v′(o′).ō′⟨l, o′, v⟩)
\overline{}^{τ} (νo)(o := [l = ς(x)x.l] | ō⟨l, o, v⟩)
\overline{}^{τ} (νo)(o := [l = ς(x)x.l] | l̄o | l(x).(νv′)(v̄′x | v′(o′).ō′⟨l, o′, v⟩))
\overline{}^{τ} (νo)(o := [l = ς(x)x.l] | (νv′)(v̄′o | v′(o′).ō′⟨l, o′, v⟩))
\overline{}^{τ} (νo)(o := [l = ς(x)x.l] | ō⟨l, o, v⟩)

[figure: l_{2}; old l_{2}; l_{1}; o; o′; Lookup starts; at the original; receiver; Activate method l; at object o′; l = l_{2}]

Figure 1: Method override and lookup

Our next example is somewhat more complicated and illustrates the encoding of method override. Consider the object

a = [l_{1} = ς(x)x, l_{2} = ς(x)b]

If we override a method then we get a new object with the overridden method exchanged with the overriding one. In our encoding this is simulated by generating a new “object” that handles activations of the overriding method itself and delegates all other method activations to the original object. This is illustrated in Figure 4.3.

The following shows how method override and lookup are handled by our encoding:

[[(a.l_{2} ⇐ ς(x)x.l_{1}).l_{2}]]_{v}
=  (νv′)((νv′′)((νo)(v̄′′o | o := a) | v′′(o^{∗}).(νo′)(v̄′o′ |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l_{2}(x).[[x.l_{1}]]_{v′′} + l_{1}(−).ō^{∗}⟨l′′, o′′, v′′⟩) | v′(o).ō⟨l_{2}, o, v⟩)
\overline{}^{τ} _{d}^{2} (νo′)((νo)(o := [l_{1} = ς(x)x, l_{2} = ς(x)b] |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l_{2}(x).[[x.l_{1}]]_{v′′} + l_{1}(−).ō⟨l′′, o′′, v′′⟩)) | ō′⟨l_{2}, o′, v⟩)
=  (νo′)((νo)(o := [l_{1} = ς(x)x, l_{2} = ς(x)b] |!o′(l′′, o′′, v′′).(l̄′′o′′ |

l_{2}(x).(νv′)(v̄′x | v′(o).ō⟨l_{1}, o, v′′⟩) + l_{1}(−).ō⟨l′′, o′′, v′′⟩)) | ō′⟨l_{2}, o′, v⟩)

\overline{}^{τ} _{dl}^{3} (νo′)((νo)(o := [l_{1} = ς(x)x, l_{2} = ς(x)b] |!o′(l′′, o′′, v′′).(l̄′′o′′ |

l_{2}(x).(νv′)(v̄′x | v′(o).ō⟨l_{1}, o, v′′⟩) + l_{1}(−).ō⟨l_{1}, x, v′′⟩)) | ō′⟨l_{1}, o′, v⟩)

\overline{}^{τ} _{dl}^{2} (νo′, o)(!o(l′, o′, v′).(l̄′o′ | l_{1}(x).v̄′x + l_{2}(x).[[b]]_{v′}) |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l_{2}(x).[[x.l_{1}]]_{v′′} + l_{1}(−).ō⟨l′′, o′′, v′′⟩) | ō⟨l_{1}, o′, v⟩)
\overline{}^{τ} _{dl}^{2} (νo′)((νo)(o := [l_{1} = ς(x)x, l_{2} = ς(x)b] |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l_{2}(x).[[x.l_{1}]]_{v′′} + l_{1}(−).ō⟨l′′, o′′, v′′⟩)) | v̄o′)

Observe how the object reference of the original receiver is passed on when the receiver does not have the requested method itself. This ensures that when the correct method is found, we know where to start looking for other methods.

4.4 Alternative encodings

In [San96] (and a previous version of this paper) a somewhat different encoding of the untyped ς-calculus is presented. The difference is in the use of matching instead of choice and communication:

[[a.l]]_{v} = (νv′)([[a]]_{v′} | v′(o).ō⟨l, o, v⟩)
[[[l_{i} = ς(x_{i})b_{i}]]] = (νo)(v̄(o) |!o(l′, o′, v′).(∏[l′ = l_{i}](νx_{i})(x̄_{i}o′ | [[b_{i}]]_{v′})))
[[x]]_{v} = x(o).v̄o
[[a.l ⇐ ς(x)b]] = (νv′)([[a]]_{v′} | v′(o).(νo′)(v̄o′ |!o′(l′′, o′′, v′′).
([l′′ = l](νx)(x̄o′′ | [[b]]_{v′′}) | [l′′ ≠ l]ō⟨l′′, o′′, v′′⟩)))

Other possibilities exist: In [San96] the typed ς-calculus is translated into an extended version of the ς-calculus with a special case construct instead of matching. This encoding does not use the ‘relay’ construct when dealing with method override. Instead the original object is setd a special message with the name of the overriding method, which it then inserts instead of the original method. This implies that each method will need two method names, one for method activation and one for method override.

5 Operational Correspondence

In this section we present number of results about our encoding, which together show the soundness of our encoding w.r.t. the operational semantics of the two calculi.

Our first lemma is a substitution lemma. It states that the ‘relay’ construct in parallel with an encoded object corresponds to binding an object reference to a self variable within the object.

Lemma 1 Let a = [l_{i} = ς(x_{i})b_{i}], then

(νo)(o := a | [[b]]_{v}{^{o}/_{x}}) ∼ [[b{^{a}/_{x}}]]_{v}

Proof. Induction in the structure of b.

b = y : We have two cases, either y = x and we have:

(νo)(o := a | [[x]]_{v}{^{o}/_{x}}) = (νo)(o := a | v̄o)
= [[a]]_{v}
= [[x{^{a}/_{x}}]]_{v}
or y ≠ x and:
(νo)(o := a | [[y]]_{v}{^{o}/_{x}}) = (νo)(o := a | v̄y)
∼ [[y]]_{v}
= [[y{^{a}/_{x}}]]_{v}

b = b′.l : Assume w.l.o.g. that v′ ∉ fn(o := a), then

(νo)(o := a | [[b′.l]]_{v}{^{o}/_{x}})
= (νo)(o := a | (νv′)([[b′]]_{v′}{^{o}/_{x}} | v′(o).ō⟨l, o, v⟩))
{IH \atop ∼} (νv′)([[b′\{^{a}/_{x}\}]]_{v′} | v′(o).ō⟨l, o, v⟩)
= [[b′{^{a}/_{x}}.l]]_{v}
= [[b.l{^{a}/_{x}}]]_{v}

b = [l_{i} = ς(x_{i})b_{i}] : Assume w.l.o.g. that x_{i} ≠ x, then

(νo)(o := a | [[[l_{i} = ς(x_{i})b_{i}]]]_{v}{^{o}/_{x}})
= (νo)(o := a | (νo′)(v̄o′ |!o′(l′′, o′′, v′′)(l̄′′o′′ | ∑ l_{i}(x_{i}).[[b_{i}]]_{v′′})))
∼ (νo′)(v̄o′) |!o′(l′′, o′′, v′′).(l̄′′o′′ |  (1)
∑ l_{i}(x_{i}).(νo)(o := a | [[b_{i}]]_{v′′})))
{IH \atop ∼} (νo′)(v̄o′ |!o′(l′′, o′′, v′′).(l̄′′o′′ | ∑ l_{i}(x_{i}).[[b_{i}\{^{a}/_{x}\}]]_{v′′}))
= [[[l_{i} = ς(x_{i})b_{i}{^{a}/_{x}}]]]_{v}
= [[[l_{i} = ς(x_{i})b_{i}]{^{a}/_{x}}]]_{v}

In (1) we distribute the replication over the sum. It can be shown that this is valid if every free occurrence of o in each component is a negative subject, that is o is only used for output.

b = b′.l ⇐ ς(y)c : Assume w.l.o.g. that y ≠ x, then

(νo)(o := a | [[b′.l ⇐ ς(y)c]]_{v}{^{o}/_{x}})
= (νo)(o := a | (νv′)([[b′]]_{v′} | v′(o^{∗}).(νo′)(v̄o′ |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l(y).[[c]]_{v′′} + ∑ m(−).ō^{∗}⟨l′′, o′′, v′′⟩))){^{o}/_{x}})
∼ (νv′)((νo)(o := a | [[b′]]_{v′}{^{o}/_{x}}) | v′(o^{∗}).(νo′)(v̄o′ |  (2)
!o′(l′′, o′′, v′′).(l̄′′o′′ | l(y).(νo)(o := a | [[c]]_{v′′}{^{o}/_{x}}) +
∑ m(−).ō⟨l′′, o′′, v′′⟩)))
{IH \atop ∼} (νv′)([[b′\{^{a}/_{x}\}]]_{v′} | v′(o^{∗}).(νo′)(v̄o′ |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l(y).[[c{^{a}/_{x}}]]_{v′′} + ∑ m(−).ō^{∗}⟨l′′, o′′, v′′⟩)))
= [[b{^{a}/_{x}}.l ⇐ ς(y)c{^{a}/_{x}}]]_{v}
= [[(b.l ⇐ ς(y)c){^{a}/_{x}}]]_{v}

The distribution of the replication in (2) sound for the same reasons as in (1).

□

As an immediate corollary we get that the encoding is sound w.r.t. the rule for method calls:

Corollary 1 Let a = [l_{i} = ς(x_{i})b_{i}] for l_{i} ∈ L then

[[a.l_{j}]]_{v} ≈ [[b_{j}{^{a}/_{x_{j}}}]]_{v} for all l_{j} ∈ L Proof. We have:

[[a.l_{j}]]_{v} = (νv′)((νo)(v̄′o | o := a) | v′(o′).ō′⟨l_{j}, o′, v⟩)
\overline{}^{τ} _{d} (νo)(o := a | ō⟨l_{j}, o, v⟩)
\overline{}^{τ} _{dl} (νo)(o := a | l̄_{j}o | ∑ l_{i}(x_{i}).[[b_{i}]]_{v})
\overline{}^{τ} _{d} (νo)(o := a | [[b_{j}]]\{^{o}/_{x_{j}}\})
∼ [[b_{j}{^{a}/_{x_{j}}}]]_{v}
□

Using algebraic techniques from the asynchronous π-calculus, we can also show that method override is sound:

Lemma 2 Let a = [l_{i} = ς(x_{i})b_{i}] for l_{i} ∈ L, then

[[a.l ⇐ ς(x)b]]_{v} ≈ [[[l_{i} = ς(x_{i})b_{i}, l = ς(x)b]]]_{v}

Proof. We have:

[[a.l ⇐ ς(x)b]]_{v}
= (νv′)([[a]]_{v′} | v′(o′).(νo)(v̄o |!o(l′′, o′′, v′′).

(l̄′′o′′ | l(x).[[b]]_{v′′} + ∑ m_{i}(−).ō′⟨l′′, o′′, v′′⟩))) m_{i} ∈ m(a) \ {l}

\overline{}^{τ} _{d} (νo^{∗})(!o^{∗}(l′, o′, v′).(l̄′o′ | ∑ l_{i}(x_{i}).[[b_{i}]]_{v′}) | (νo)(v̄o |
!o(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[b]]_{v′′} + ∑ m_{i}(−).ō^{∗}⟨l′′, o′′, v′′⟩)))

Now we push the replication that represents the a object under the sum ∑ m(−) and get:

(νo)(v̄o |!o(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[b]]_{v′′} + ∑ m_{i}(−).
(νo^{∗})(ō^{∗}⟨l′′, o′′, v′′⟩ |!o^{∗}(l′, o′, v′).(l̄′o′ | ∑ l_{i}(x_{i}).[[b_{i}]]_{v′}))))

The above is valid due to the fact than whenever o^{∗} is a private name and the overriding method is activated, this cannot happen with o^{∗} as the self reference, that is, if the encoding of a is activated it will be through o.

Since o^{∗} does not occur free in any of the [[b_{i}]]_{v′} this implies that we can remove the replication of o^{∗} and replace the internal communication over o^{∗} with an internal move:

(νo)(v̄o |!o(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[b]]_{v′′} +
∑ m_{i}(−).τ.(l̄′′o′′ | ∑ l_{i}(x_{i}).[[b_{i}]]_{v′′})))

Finally we can remove the innermost sum (∑ l_{i}(x_{i}).[[b_{i}]]_{v′′}) and instead bind the self variables in the outermost sum:

∼ (νo)(v̄o |!o(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[b]]_{v′′} + ∑ m_{i}(x_{i}).τ.τ.[[b_{i}]]_{v′′})))
≈ (νo)(v̄o |!o(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[b]]_{v′′} + ∑ m_{i}(x_{i}).[[b_{i}]]_{v′′})))
= [[[l_{i} = ς(x_{i})b_{i}, l = ς(x)b]]]_{v}
□

With these lemmas we are now able to prove that reductions in the ςcalculuscorrespond to transition sequences in the π-calculus. More precisely, when an object a can do a reduction and become a′, then our encoding can match that by doing a series of internal actions, resulting in a π-calculus process being weakly bisimilar to a′.

Theorem 1 If a ⇝ b then [[a]]_{v} ^{\overline{}^{τ}} ^{∗} P ≈ [[b]]_{v}.

Proof. Induction in the structure of a.

a = x: We have a ⇝̸.

a = [l_{i} = ς(x_{i})b_{i}]: Again a ⇝̸.

a = a′.l: If a ⇝ b it can be for two reasons:

i. a′ ⇝ a′′ and [[a]]_{v} = (νv′)([[a′]]_{v′} | v′(o).ō⟨l, o, v⟩). By induction

there exist a P such that [[a′]]_{v′} ^{\overline{}^{τ}} ^{∗} P ≈ [[a′′]]_{v′}. And then:

(νv′)(P | v′(o).ō⟨l, o, v⟩) ≈ (νv′)([[a′′]]_{v′} | v′(o).ō⟨l, o, v⟩) = [[a′′.l]]_{v}

ii. a′ = [l_{i} = ς(x_{i})b_{i}] with l = l_{j}, b = b_{j}{^{a′}/_{x_{j}}}. We have
[[a]]_{v} = (νv′)((νo)(v̄′o | o := [l_{i} = ς(x_{i})x_{i}]) | v′(o′).ō′⟨l, o′, v⟩)
\overline{}^{τ} _{d} (νo)(o := [l_{i} = ς(x_{i})x_{i}] | ō⟨l, o, v⟩)
\overline{}^{τ} _{dl}^{2} \underbrace{(νo)(o := [l_{i} = ς(x_{i})x_{i}] | [[b_{j}]]_{v}\{^{o}/_{x_{j}}\})}_{P}

According to Lemma 1 we have P ∼ [[b_{j}{^{[l_{i} = ς(x_{i})b_{i}]}/_{x_{j}}}]]_{v}.

a = a′.l ⇐ ς(x)c: Again we have two cases.

i. a′ ⇝ a′′ is handled as in the previous case. ii. a′ = [l_{i} = ς(x_{i})b_{i}] and b = [l_{i} = ς(x_{i})b_{i}, l = ς(x)c]. According to

Lemma 2 we have:

[[[l_{i} = ς(x_{i})b_{i}].l ⇐ ς(x)c]]_{v} ≈ [[[l_{i} = ς(x_{i})b_{i}, l = ς(x)c]]]_{v}
□

Our encoding signals the reduction of ς-calculus term to an object as the output of an object identifier, this we express as:

Theorem 2 If a ⇝^{∗} [l_{i} = ς(x_{i})b_{i}] = b then [[a]]_{v} ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{v̄(o)}} ≈ o := b.

Proof. We use induction in the length of a ⇝^{n} a′.

Basis n = 0: We must have a = [l_{i} = ς(x_{i})b_{i}] and for the encoding we have

[[[l_{i} = ς(x_{i})b_{i}]]]_{v} = (νo)(v̄o | o := [l_{i} = ς(x_{i})b_{i}])
\overline{}^{v̄(o)} o := [l_{i} = ς(x_{i})b_{i}]

Induction step: Assume that the theorem holds for sequences of reduction steps of length n. We now consider a reduction sequence of length n+1, that is we have

a ⇝ a′ ⇝^{n} b = [l_{i} = ς(x_{i})b_{i}]

According to the induction hypothesis there exists a P such that:

[[a′]]_{v} ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{v̄(o)}} P ≈ o := b

According to Theorem 1 there exist a Q such that [[a]]_{v} ^{\overline{}^{τ}} ^{∗} Q ≈ [[a′]]_{v}. We now have the following sequence:

[[a]]_{v} ^{\overline{}^{τ}} _{dl}^{∗} Q ≈ [[a′]]_{v} ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{v̄(o)}} P ≈ o := b

Since Q ≈ [[a′]]_{v} the must exist a Q′ such that

[[a]]_{v} ^{\overline{}^{τ}} ^{∗} Q ^{\overline{}^{τ}} ^{∗} ^{\overline{}^{v̄(o)}} Q′ ≈ P ≈ o := b

□

The relationship between transitions in the π-calculus encoding and reductions in the ς-calculus is somewhat more difficult to express, since the π-calculus encoding may need to do some internal computation before being ready to simulate an object. We relate reductions through the output of an object identifier. If we after a series of internal actions see an external action, then this is because the original ς-calculus term can reduce to an object.

Theorem 3 If fv(a) = ∅ and [[a]]_{v} ^{\overline{}^{τ}} ^{∗} ^{\overline{}^{α}} P then α = v̄(o) and

a ⇝^{∗} [l_{i} = ς(x_{i})b_{i}] = b and P ≈ o := b

Proof. We shall use induction in the number of τ-moves prior to an observable action.

Basis n = 0: The only process immediately capable of performing an observable action is:

[[[l_{x} = ς(x_{x})i_{x}]]]_{v} ^{\overline{}^{v̄(o)}} o := [l_{x} = ς(x_{x})i_{x}]

And obviously the theorem holds. The other “possibility” [[x]]_{v} is prohibited.

Induction step: Assume that the theorem holds for τ-sequences of length n. We now consider at τ-sequence of length n + 1 before an external action.

For [[a]]_{v} to have any τ-moves a must be either:

a = a′.l: Here we have

[[a′.l]]_{v} = (νv′)([[a′]]_{v′} | v′(o).ō⟨l, o, v⟩) ^{\overline{}^{τ}} ^{n+1} P

Now [[a′]]_{v′} must have less than n+1 τ-moves before an observable action (remember, we disregard observable actions from method activations), since the only action possible action is with v′ as subject, resulting in one internal communication in [[a]]_{v}. Therefore, by induction

[[a′]]_{v′} ^{\overline{}^{τ}} _{dl}^{m} ^{\overline{}^{v̄′(o′)}} Q ≈ o′ := c (m ≤ n)

and combining things we get

(νv′)([[a′]]_{v′} | v′(o).ō⟨l, o, v⟩) ^{\overline{}^{τ}} _{dl}^{m+1} (νo′)(o′ := c | ō′⟨l, o′, v⟩)

Applying the induction hypothesis once more

(νo′)(o′ := c | ō′⟨l, o′, v⟩) ^{\overline{}^{τ}} ^{k} ^{\overline{}^{v̄(o)}} ≈ o := b (k = n − m)

All in all

(νv′)([[a′]]_{v′} | v′(o).ō⟨l, o, v⟩) ^{\overline{}^{τ}} ^{m} ^{\overline{}^{τ}} ^{\overline{}^{τ}} ^{k} ^{\overline{}^{v̄(o)}} ≈ o := b

a = a′.l ⇐ ς(x)c: In the encoding we have:

[[a′.l ⇐ ς(x)c]]_{v} = (νv′)([[a′]]_{v′} | v′(o).(νo′)(v̄o′ |!o′(l′′, o′′, v′′).

(l̄′′o′′ | l(x).[[c]]_{v′′} + m(−).ō⟨l′′, o′′, v′′⟩)))

Using the same line of reasoning as in the previous case we get

(νv′)([[a′]]_{v′} | v′(o).(νo′)(v̄(o′) |!o′(l′′, o′′, v′′).
(l̄′′o′′ | l(x).[[c]]_{v′′} + m(−).ō⟨l′′, o′′, v′′⟩)))
[figure: τ; n+1; v̄(o)]
(νo′)(o′ := c′ |!o′(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[c]]_{v′′} +  (3)
m(−).ō⟨l′′, o′′, v′′⟩))

With c′ ≈ [l_{i} = ς(x_{i})b_{i}]. Now according to Lemma 2 (4) is weakly bisimilar to o′ := [l_{i} = ς(x_{i})b_{i}, l = ς(x)c].

□

6 Equivalences for the ς-calculus

As an operational equivalence for the ς-calculus we shall use context equivalence as defined in [GR95], except that we do not take the type of contexts into account.

Definition 2 (Context equivalence) A relation R is a context ς-equivalence if it is symmetric and a R b implies:

• If a ⇓ then b ⇓ and for all contexts C[·] we C[a] R C[b].

Two objects are context ς-equivalent (written a ≃ b) if a R b for some context ς-equivalence.

In [GR95] Gordon and Rees show that context equivalence correspond to bisimulation in a labelled transition system for ς-calculus terms.

The omission of type information has important implications. When we restrict our attention to well-typed ς-calculus terms, we prohibit terms such as [ ].l, that is, objects where we try to activate nonexisting methods. It is quite easy to see that the only terms bisimilar are objects which also terminate with the attempt to activate a nonexisting method.

The use of restriction of method names at the outermost level has the implication that the expected result, namely that weak bisimulation between encoded terms implies context equivalence, does not hold. The problem is that once we have restricted the method names away, we cannot activate any methods and see how the encoding of the objects behaves. To illustrate the problem, consider the following two objects, that are definitely not context equivalent:

a = [l = ς(x)x] b = [l = ς(x)x.l]

With the restriction of method names at the outermost level we have:

[[a]]_{v}
= (νl)((νo)(v̄o |!o(o′, l′, v′).(l̄′o′ | l(x).v̄′x))
\overline{}^{v̄(o)} (νl)(!o(l′, o′, v′).(l̄′o′ | l(x).v̄′x))
∼ !o(l′, o′, v′).(l̄′o′ | (νl)(l(x).v̄′x)))
∼ !o(l′, o′, v′).l̄′o′

This is also the case for [[b]]_{v} so we have [[a]]_{v} ≈ [[b]]_{v} but a.l ⇓ and b.l ⇑.

On the other hand, if we drop the restriction of method names, then it is easily shown that weak bisimulation between encodings of terms implies context equivalence of the original terms.

Theorem 4 If [[a]]_{v} ≈ [[b]]_{v} then a ≃ b

Proof. Assume that [[a]]_{v} ≈ [[b]]_{v}, then because ≈ is a congruence we have C_{π}[[[a]]_{v}] ≈ C_{π}[[[b]]_{v}] for all π-calculus contexts, and in particular for contexts that are encodings of some ς-calculus context. If C_{π}[·] is the encoding of the ςcalculus context C[·] then we have C_{π}[[[a]]_{v}] = [[C[a]]]_{v′} and C_{π}[[[b]]_{v}] = [[C[b]]]_{v′} for some v′.

Now we know from Theorem 3 that if [[C[a]]]_{v′} performs an observable action on v′, then it is because C[a] terminates. Furthermore, if [[C[a]]]_{v′} ≈ [[C[b]]]_{v′} then [[C[b]]]_{v′} then must also have an observable action on v′, what implies that C[b] must also terminate, and vice versa.

That is, if we have [[a]]_{v} ≈ [[b]]_{v} then we have a ≃ b. □

The reverse implication of Theorem 4 does not hold; for instance

a = [l = ς(x)x] b = [l = ς(x)a]

If we do not allow addition of methods in method override, then we have a ≃ b, but their encodings are easily distinguished. For the first we have the following transition sequence:

[[a]]_{v} ^{\overline{}^{v̄(o)}} o := a ^{\overline{}^{o(l,o,v)}} ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{v̄(o)}} o := a

And for the encoding of the second:

[[b]]_{v} ^{\overline{}^{v̄(o)}} o := b ^{\overline{}^{o(l,o,v)}} ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{v̄(o′)}} o := b | o′ := a

If we allow addition of methods, then a and b are not context bisimilar, since b after the activation of l will “lose” the added method.

It is not enough to allow the addition of methods, to see why consider:

a = [l = ς(x)x]  b = [l = ς(x)x.l ⇐ ς(x)x]

These two object are congruent, even if we allow addition of methods, but their encodings are not weak bisimilar since the overriding in b results in the creation of a new object reference.

If fact, when we remove the restriction of method names we obtain a very fine-grained equivalence between ς-calculus terms. This is essentially due to the fact two objects are weakly bisimilar in their encoding when they activate the same methods at the same time. For instance, consider:

a = [l = ς(x)[l_{1} = ς(y)x].l_{1}] b = [l = ς(x)[l_{2} = ς(y)x].l_{2}]

These two object are obviously equivalent with respect to their reductions, but since the innermost methods have different names the encodings of a and b are not weakly bisimilar.

To characterize ς-equivalence, we need to restrict ourselves to π-calculus contexts which are encodings of ς-calculus contexts:

Definition 3 A symmetric relation R_{v} is a ςπ-bisimulation if P R_{v} Q implies that if P ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{α}} P′ then Q ^{\overline{}^{τ}} _{dl}^{∗} ^{\overline{}^{α}} Q′, α = v̄(o) and

• For all l ∈ Method:

(νo)(P′ | ō⟨l, o, v⟩) R_{v} (νo)(Q′ | ō⟨l, o, v⟩)

• For all l ∈ Method, x and c:

(νo, o′)(P′ | v̄(o′).!o′(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[c]]_{v′′} + ∑ m(x).ō⟨l′′, o′′, v′′⟩))

R_{v}

(νo, o′)(Q′ | v̄(o′).!o′(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[c]]_{v′′} + ∑ m(x).ō⟨l′′, o′′, v′′⟩))

Using the operational correspondence between ς-calculus terms and their encoding we can prove that if two ς-calculus terms are ς-equivalent then their encodings are contained in some ςπ-bisimulation.

Theorem 5 If a ≃ b, then there exist a ςπ-bisimulation R_{v} such that [[a]]_{v} R_{v} [[b]]_{v}.

Proof. Let R_{v}= {([[c_{1}]]_{v}, [[c_{2}]]_{v}) | c_{1} ≃ c_{2}}. Obviously we have [[a]]_{v} R_{v} [[b]]_{v}. We now claim that R_{v} is a ςπ-bisimulation up to ≈.

Let [[c_{1}]]_{v} R_{v} [[c_{2}]]_{v}, we now consider what behaviour [[c_{1}]]_{v} can have.

[[c_{1}]]_{v} ⇑: By the operational correspondence this must be because c_{1} ⇑. Since c_{1} ≃ c_{2}, [[c_{2}]]_{v} must also diverge.

[[c_{1}]]_{v} ^{\overline{}^{τ}} ^{∗} P ↛: This implies that c_{1} ⇝^{∗} C[[l_{i} = ς(x_{i})b_{i}].l] with l_{i} ∈ L_{1} and l ∉ L_{1}. Since c_{1} ≃ c_{2} we also have c_{2} ⇝^{∗} C[[l_{j} = ς(x_{j})b_{j}].l] with l_{j} ∈ L_{2} and l′ ∉ L_{2} and again by the operational correspondence we

have [[c_{2}]]_{v} ^{\overline{}^{τ}} ^{∗} Q ↛.

[[c_{1}]]_{v} ^{\overline{}^{τ}} ^{\overline{}^{v̄(o)}} P: This implies that a ⇝^{∗} [l_{i} = ς(x_{i})b_{i}] with P ≈ o := [l_{i} = ς(x_{i})b_{i}]. Since c_{1} ≃ c_{2}, c_{2} ⇝ [l_{j} = ς(x_{j})b_{j}] with [l_{i} = ς(x_{i})b_{i}] ≃ [l_{j} = ς(x_{j})b_{j}] and therefore [[c_{2}]]_{v} ^{\overline{}^{τ}} ^{\overline{}^{v̄(o)}} Q with Q ≈ o := [l_{j} = ς(x_{j})b_{j}].

By the definition of ≃ we must have [l_{i} = ς(x_{i})b_{i}].l ≃ [l_{j} = ς(x_{j})b_{j}].l and [l_{i} = ς(x_{i})b_{i}].l ⇐ ς(c)x ≃ [l_{j} = ς(x_{j})b_{j}].l ⇐ ς(c)x. Now, using Lemma 1, we have:

(νo)(P | ō(l, o, v)) ≈ [[[l_{i} = ς(x_{i})b_{i}].l]]_{v}
R_{v} [[[l_{j} = ς(x_{j})b_{j}].l]]_{v} ≈ (νo)(Q | ō(l, o, v))

and Lemma 2

(νo, o′)(P | v̄(o′).!o′(l′′, o′′, v′′).(l̄′′o′′ | l(x).[[c]]_{v′′} +
∑ m(−).ō⟨l′′, o′′, v′′⟩))
≈ [[[l_{i} = ς(x_{i})b_{i}, l = ς(x)c]]]_{v}
R_{v} [[[l_{j} = ς(x_{j})b_{j}, l = ς(x)c]]]_{v}
≈ (νo)(Q | ō(l, o, v))
□

The reverse implication also holds; that is, if we can find a ςπ-bisimulation for the encoding of two ς-calculus terms, then they are ς-equivalent.

Theorem 6 If [[a]]_{v} R_{v} [[b]]_{v} for some ςπ-bisimulation then a ≃ b.

Proof. Let [[a]]_{v} R_{v} [[b]]_{v} for some ςπ-bisimulation. We now claim that a and b have the same termination behaviour in all contexts.

Clearly, by the operational correspondence, if [[a]]_{v} ⇑ then also a ⇑ and the same holds for b.

Also by the operational correspondence, if [[a]]_{v} ^{\overline{}^{τ}} ^{\overline{}^{v̄(o)}} P then a ⇝^{∗} [l_{i} = ς(x_{i})b_{i}] with P ≈ o := [l_{i} = ς(x_{i})b_{i}] and similarly for b. Therefore a and b must have the same termination behaviour. By definition of R_{v} this must also hold for all context that a and b can be put in. □

7 Conclusions and further work

In this paper we have described how to encode the simple untyped object calculus of Abadi and Cardelli into the asynchronous π-calculus without matching. We chose this calculus to see how simple a calculus we would need to encode the ς-calculus. As this paper shows, it is possible to encode the ς-cal-culus into our target calculus, but the price is somewhat high. The proofs of operational correspondence rely on specific assumptions about the use of method names in the encoding, and as Section 6 shows, weak bisimilarity between encoded terms gives us a very fine-grained equivalence between ς-cal-culus terms, since it requires two objects to have the same method activation behaviour to be equivalent.

In [San96] Sangiorgi investigates well-typed encodings of the ς-calculus into the π-calculus. His work is very similar to the work presented in this paper ; however, Sangiorgi uses a version of the synchronous π-calculus extended with a case operator.

The authors are currently working on an encoding of the imperative object calculus [AC95b, AC95a]. The imperative object calculus is interesting in that it incorporates references to objects, a phenomenon common to many object-oriented programming languages. Because of the presence of references, the semantics of the imperative object calculus is quite similar to our encoding.

References

[Abr89] S. Abramsky. The lazy lambda-calculus. In D. Turner, editor, Research Topics in Functional Programming, pages 65–116. Addison-Wesley, 1989.

[AC94a] Martin Abadi and Luca Cardelli. A semantics of object types. In Proceedings of the 9th IEEE Symposium on Logics in Computer Science, pages 332–341. IEEE Computer Society, Computer Society Press, 1994.

[AC94b] Martin Abadi and Luca Cardelli. A theory of primitive objects: Second-order systems. In Proceedings of European Symposium on Programming, volume 788 of Lecture Notes in Computer Science, pages 1–25. Springer-Verlag, 1994.

[AC95a] M. Abadi and L. Cardelli. An imperative object calculus: Basic typing and soundness. In SIPL ’95 - Proc. Second ACM SIGPLAN Workshop on State in Programming Languages. Technical Report UIUCDCS-R-95-1900, Department of Computer Science, University of Illinois at Urbana-Champaign, 1995.

[AC95b] Martin Abadi and Luca Cardelli. An imperative object calculus. Theory and Practice of Object Systems, 1(3):151–166, 1995.

[AC96] Martin Abadi and Luca Cardelli. A theory of primitive objects – untyped and first-order systems. Information and Computation, 125(2):78–102, 1996.

[Ame89] P. America. Issues in the design of a parallel object-oriented language. Formal Aspects of Computing, 1(4):396–411, 1989.

[Bou92] Gérard Boudol. Asynchrony and the π-calculus. Technical report, INRIA Sophia-Antipolis, 1992.

[CS96] Roberto M. Amadio Ilaria Castellani and Davide Sangiorgi. On bisimulations for the asynchronous π-calculus. In Proceedings of CONCUR 96, Lecture Notes in Computer Science. Springer-Verlag, 1996.

[GR95] A. D. Gordon and G. D. Rees. Bisimilarity for a first-order calculus of objects with subtyping. In Proceedings of the Twenty-Third Annual ACM Symposium on Principles of Programming Languages, St. Petersburg Beach, Florida, January 1996. ACM, 1995.

[HK95] Martin Hansen Hans Hüttel and Josva Kleist. Bisimulations for asynchronous mobile processes. In Proceedings of the Tbilisi Symposium on Language, Logic and Computation, 1995.

[HT91] K. Honda and M. Tokoro. An object calculus for asynchronous communication. In ECOOP 91, volume 512 of Lecture Notes in Computer Science, pages 133–147. Springer-Verlag, 1991.

[Mil92] Robin Milner. Functions as processes. Journal of Mathematical Structures in Computer Science, 2(2):119–141, 1992.

[PW92] Robin Milner Joachim Parrow and David Walker. A calculus of mobile processes — part i and ii. Information and Computation, 100:1–77, 1992.

[San96] Davide Sangiorgi. An interpretation of typed objects into typed π-calculus. Research Report RR-3000, INRIA Sophia Antipolis, August 1996.

[Wal95] David Walker. Objects in the π-calculus. Information and Computation, 116:253–271, 1995.

Recent Publications in the BRICS Report Series

RS-96-38 Hans H� uttel and Josva Kleist. Objects as Mobile Processes. October 1996. 23 pp.

RS-96-37 Gerth St�lting Brodal and Chris Okasaki. Optimal Purely Functional Priority Queues. October 1996. 27 pp. To appear in Journal of Functional Programming, 6(6), December 1996.

RS-96-36 Luca Aceto, Willem Jan Fokkink, and Anna Ing� olfsd� ottir. On a Question of A. Salomaa: The Equational Theory of Regular Expressions over a Singleton Alphabet is not Finitely Based. October 1996. 16 pp.

RS-96-35 Gian Luca Cattani and Glynn Winskel. Presheaf Models for Concurrency. October 1996. 16 pp. Presented at the Annual Conference of the European Association for Computer Science Logic, CSL ’96.

RS-96-34 John Hatcliff and Olivier Danvy. A Computational Formalization for Partial Evaluation (Extended Version). October 1996. To appear in Mathematical Structures in Computer Science.

RS-96-33 Jonathan F. Buss, Gudmund Skovbjerg Frandsen, and Jeffrey Outlaw Shallit. The Computational Complexity of Some Problems of Linear Algebra. September 1996. 39 pp.

RS-96-32 P. S. Thiagarajan. Regular Trace Event Structures. September 1996. 34 pp.

RS-96-31 Ian Stark. Names, Equations, Relations: Practical Ways to Reason about ‘new’. September 1996. ii+22 pp.

RS-96-30 Arne Andersson, Peter Bro Miltersen, and Mikkel Thorup. Fusion Trees can be Implemented with AC^{0} Instructions only. September 1996. 8 pp.

RS-96-29 Lars Arge. The I/O-Complexity of Ordered Binary-Decision Diagram Manipulation. August 1996. 35 pp. An extended abstract version appears in Staples, Eades, Kato, and Moffat, editors, Algorithms and Computation: 6th International Symposium, ISAAC ’95 Proceedings, LNCS 1004, 1995, pages 82�91.