Tải bản đầy đủ - 0 (trang)
3 Type Rules for Terms, Assertions and Conditions

3 Type Rules for Terms, Assertions and Conditions

Tải bản đầy đủ - 0trang

Binary Session Types for Psi-Calculi


5.4 Type Rules for Processes

Type judgements for processes are of the form Γ , Ψ P, where Ψ is an assertion.

Table 3 contains the type rules for processes. In the type rules, and notably in (PAR ),

we use a typed notion of frames for processes; the qualified frame of a process P is still

denoted F (P) but is now a pair ΓP , ΨP , where ΨP is the composition of assertions in

P and ΓP records the types of the names local to ΨP . We define this as follows

F (P | Q) = ΓP + ΓQ , ΨP ΨQ

where F (P) = ΓP , ΨP , F (Q) = ΓQ , ΨQ

F ((ν b : T )P) = b : T + ΓP , ΨP where F (P) = (ΓP , ΨP )

F ((|Ψ |)) = 0,

/ Ψ

F (P) = 0,

/ 1


For patterns, judgments are of the form Γ , Ψ X : T → U. The intended interpretation is that pattern X has type T → U if the pattern variables are bound to terms of

types T whenever the pattern matches a term of type U. An important rule is (PAR ); the

type addition axiom (2) enables us to split a session type into two endpoint types, one

for each parallel component; this follows Giunti and Vasconcelos [14].

The type rules for input and output generalize those of usual session type systems

such as [14]. In particular, the subject and the object of the prefix are typed in separate

subenvironments and the type of the subject is updated when typing the continuation.

As subjects in the psi-calculus setting can be arbitrary terms, one cannot simply update

the session type of a channel by updating the type bound to the channel in the type

environment. Instead, we update the type of the channel constructor used to construct

the channel.

6 A Type Preservation Theorem

We now establish a fidelity result that will ensure that whenever a process P is welltyped in a balanced environment, then in any τ -transition that is the result of a communication or selection on a session channel constructed using session constructor c, the

resulting process will also be well-typed in a balanced environment – only now the type

of c has evolved according to the protocol specified by the session type.

The direction of a visible action α in the labelled semantics is either ! or ? for a

communication and or for a selection; we denote this by d(α ).

Definition 6 (Well-typed label). Let α be a label. We call (α , (T,U)) a typed label if

U is either a type or •. We define Γ , Ψ α : (T @c,U) as follows:


1. If Γ1 , Ψ1 M : T @c and Γ2 + a : T , Ψ2 N : U and T −→ T then Γ1 + Γ2 , Ψ1

M(ν a)N : (T @c,U).


2. if Γ1 , Ψ1 K : T @c and Γ2 , Ψ2 N : U and T −→ T then Γ1 + Γ2 , Ψ1 Ψ2

(T @c,U) .

3. If Γ , Ψ


M : T @c and T −−→ T then Γ , Ψ


l : (T @c, ).


KN :


H. Hăuttel

Table 3. Psi-calculus type rules


4. If , Ψ M : T @c and T −−→ T then Γ , Ψ M l : (T @c, •).

5. If Γ1 , Ψ1 , b1 : V1 M(ν a)N : (T @c,U) and Γ2 , Ψ2 , b2 : V2 , a : V3 KN : (T @c,U)

then Γ1 + Γ2 , Ψ1 Ψ2 (ν b1 ∪ b2 )τ @(ν a)(M N K) : (T @c,U).

6. If Γ1 + Γ11 , Ψ1 M l : (T @c, •) and Γ2 + Γ12 , Ψ2 K l : (T @c, •) then Γ1 +

Γ2 , Ψ1 Ψ2 τ @(ν a)(M l K) : (T @c, •), where Γ11 + Γ12 = a : T .

Binary Session Types for Psi-Calculi

We write Γ , Ψ




α : (T @c,U) if the type judgements involved in the above are all

For our result, we define session updates for τ -labels. The idea behind the definition

is that the behaviour of the session constructor should be updated in the type environment if the τ -label was due to a communication created by a free session constructor.

Otherwise, the behaviour is not mentioned in the type environment and not modified.

Definition 7 (Update for unobservable labels). Let Γ1 , Γ be type environments with

Γ1 ≤ Γ . Then

1. If Γ1 , Ψ1

(ν a)τ @(ν b)(M N K) : (T @c, T1 ) and Γ = Γ + c : (T , T ) with c ∈






T1 and T −−→

T2 , we let

b ∪ dom(Γ ) and T −→


Γ ± (ν a)τ @(ν b)(M N K : (T @c, T1 )) = Γ + c : (T1 , T2 )

2. If Γ1 , Ψ1

τ @(ν a)(M



K) : (T @c, •) and Γ = Γ + c : (T , T ) with c ∈



a, dom(Γ ) and T −−→ T1 and T −−→ T2 , we let

Γ ± τ @(ν a)(M



K) : (T @c, •) = Γ + c : (T1 , T2 )

Lemma 8 (Well-typed observable actions). Suppose we have Ψ0

Γ , Ψ P with Ψ ≤ Ψ0 . Then



→ P and that

1. If α = M l there exists a Γ ≤ Γ and a Ψ ≤ Ψ such that Γ , Ψ min α : (T1 @c, T2 )

2. If α = M l there exists a Γ ≤ Γ and a Ψ ≤ Ψ such that Γ , Ψ min α : (T1 @c, T2 )

3. If α = M(ν a)N there exists a Γ ≤ Γ , a ΓP ≤ ΓP and a Ψ ≤ Ψ such that Γ +

ΓP , Ψ min α : (T1 @c, T2 ). Moreover, dom(ΓP ) = a.

4. If α = KN there exists a Γ ≤ Γ and a Ψ ≤ Ψ , a Γ and a Ψ such that Γ +

Γ , Ψ Ψ min α : (T1 @c, T2 ) with Γ , Ψ min K : T1 @c and Γ , Ψ min N : T2 .

We can now show that all τ -transitions have a well-typed label. If P is well-typed

in a balanced type environment Γ and all type annotations of local names in P are

balanced, we write Γ , Ψ bal P,

Note that for τ -labels, the subject types involved have to be dual to each other for

the label to be well-typed.


Theorem 9 (Well-typed τ -actions). Suppose we have Ψ0 P −

→ P , where α is a τ action and that Γ , Ψ bal P and Ψ ≤ Ψ0 . Then for some Ψ ≤ Ψ and Γ ≤ Γ we have

Γ , Ψ min α : (T @c,U).

If Γ , Ψ bal P and P performs an internal move to P , the fidelity theorem tells us

that P is also well-typed wrt. a balanced type environment in which the types of the

session name involved in the action have evolved according to its protocol.


Theorem 10 (Fidelity). Suppose we have Ψ0 P −

→ P , where α is a τ -action and

that Γ , Ψ bal P. Then for some Γ ≤ Γ and for some Ψ ≤ Ψ we have Γ , Ψ min α :

(T @c,U) and Γ ± (α , (T @c,U)), Ψ bal P .

Proof. (Outline) By Theorem 9, we know that the label α is minimally well-typed; that

is, we have Γ , Ψ min α : (T @c,U) for some Γ ≤ Γ , Ψ ≤ Ψ . The rest of the proof



now proceeds by induction in the proof tree for the transition 0 P


H. Hăuttel

7 Instances of the Type System

In this section we describe how existing binary session type systems can be captured

within our generic type system. For each instance we represent the process calculus

used in the original type system as a psi-calculus and then define the sets of types, the

transition rules for session types and the addition operation on session types. We must

then supply type rules for terms, assertions and conditions.

For every existing type system with a typability relation we describe a translation

· of the original type judgements Γ P into our generic system such that we have


P ⇐⇒ Γ


In each case we show that the type rules for processes in the definition of are instances

of our generic type rules for processes together with the new type rules for terms, assertions and conditions for the instance.


Gay-Hole Sessions

The session type system due to Gay and Hole [13] introduces recursive types and subtyping for a π -calculus; the two ends of a channel c are distinct names, c+ and c− .

Session types are given by the formation rules

S :: = X | end |? T1 .T2 |! T1 .T2 | & l1 : S1 , . . . , lk : Sk | ⊕ l1 : S1 , . . . , lk : Sk | μ X.S

and endpoint types by the formation rules

T :: = X | S | μ X.T | B

Base types B are self-dual. For session types we have

end = end


? T1 .T2 = ! T1 .T2


& l1 : S1 , . . . , lk : Sk = ⊕ l1 : S1 , . . . , lk : Sk



! T1 .T2 = ? T1 .T2



μ X.S = μ X.S

⊕ l1 : S1 , . . . , lk : Sk = & l1 : S1 , . . . , lk : Sk

In our representation of the π -calculus used by [13] as a psi-calculus we represent

restriction (ν c+ , c− : T )P as (ν c : (T, T )) P and define addition by (T, T ) = T +T . The

transition rules for Gay-Hole session types include the following.

(S-I N )



? T1 .T2 −−→


(S-O UT )



(S-B RANCH ) & l1 : S1 , . . . , lk : Sk −−→




! T1 .T2 −−→




l1 : S1 , . . . , lk : Sk −−→


The corresponding psi-calculus has terms that are names and uses names to which a

session constructor has been applied to create the endpoint of a session channel. To this

end we introduce two unit new terms + and − and let c be a unary term constructor. We

then represent (ν c+ , c− : T )P as (ν c : (Unit → T, Unit → T ))P. The names c+ and c−

correspond to c(+) and c(−), respectively.

A crucial notion of the type system is that of subtyping. Using our notion of type

transitions we can capture this as follows by a coinductive definition.

Binary Session Types for Psi-Calculi


Definition 11. A type simulation is a binary relation R on types which satisfies that

whenever (T,U) ∈ R we have







1. If T −→

T2 then U −−→

U2 with (U1 , T1 ) ∈ R and (T2 ,U2 ) ∈ R



T2 then U −−→

U2 with (T1 ,U1 ) ∈ R and (T2 ,U2 ) ∈ R

2. If T −−→



3. If U −−→ U1 then T −−→ T1 with (T1 ,U1 ) ∈ R



4. If T −−→ T1 then U −−→ U1 with (T1 ,U1 ) ∈ R

If (T,U) ∈ R for some type simulation R we write T ≤ U.

The type rules for typing session channels are given below. We only have one assertion 1, and let 1 |= a ↔

˙ a and 1 |= c(+) ↔

˙ c(−).


Γ ,Ψ M : T T ≤ T

Γ ,Ψ M : T

(L OOKUP ) Γ , Ψ



if Γ (n) = T

if Γ (c) = Unit → T

if Γ (c) = Unit → T


c(+) : T @c

c(−) : T @c

7.2 A Type System for Progress

The type system by Vieira and Vasconcelos [24] captures a liveness property, namely

progress in a π -calculus: in any session, every communication requesting an input eventually takes part in a synchronization.

Session types T are annotated with events e and multiplicities linear (lin) and shared

(un); p denotes polarities and τ describes a synchronization pair.

p :: =! |? | τ

L :: = end | e lin p T.L

T :: = L | e unp T

Type judgements are of the form Γ , ≺ P where Γ is a type environment and ≺ a strict

partial order (spo) on events. Disjoint union of spo’s is denoted by ∪· and is only defined

when the ordinary union would not introduce cycles in the resulting relation. The spo

formed by adding e as new least element to the spo ≺ is denoted e+ ≺. The support

supp(≺) is the set of events occurring in ≺. We use T ↓ to define the sequence of events

that occur along the session type T :

if T = e lin p/T1 .L

⎨e + (L ↓)


T ↓ = {(end, )} if T = end

{(e, )}

if T = e un pT1

A type is matched if it does not contain pending outputs, and we then write

matched(T ).

When typing a parallel composition, the type environment is split into subenvironments for each parallel component. Two of the rules for splitting types are

L = L1 ◦ L2

e lin τ T.L = e lin !T.L1 ◦ e lin ?T.L2

e un !T = e un !T e un !T


H. Hăuttel

Thus, a linear synchronized pair can be split into an input type and an output type, while

any unlimited output type can be split into arbitrarily many copies.

Two of the type rules are shown below; Γend denotes any type environment Γ where

Γ (x) = end for all x ∈ dom(Γ ).

Γend ; {(end, ⊥)}


Γ , x : L, y : T ; ≺ P e ∈ supp(≺)

Γ , x : e lin ?T.L; e+ ≺ x(y).P

In the representation in our generic type system, names become nullary session

constructors: for any name c in the original type system we have that if c has type T ,

the corresponding c in the representation has type T @c. We use events with polarities

e+ and e− to describe how events are associated with outputs and inputs, respectively,

at channel endpoints.

The formation rules for types are now

L :: = end | e+ lin ! T.L | e− lin ? T.L

T :: = L | e+ un! T | e− un? T | e un? T | e un! T | e lin T.L

The sum operator for types is defined by

e+ lin ! T.L1 + e− lin ? T.L2 = e lin T.L

where L = L1 + L2

The transition relation for types is defined as follows.

e+ lin ! T.L −→ L

e− lin ? T.L −→ L

e+ un! T −→ e+ un! T

e− un? T −→ e− un? T





We use assertions to represent strict partial orders and to guide the application of the

prefix type rules. The formation rules for assertions are (where k ≥ 0)

Ψ :: = un x{x1 , . . . , xn }(e+ , T ) | lin x{x1 , ..., xn }(e+ , T ) | un x{x1 , ..., xn }e

| lin{x1 , ..., xn }e | {x1 , . . . , xk } ≺| 0 | matched(T )

≺ :: = {(e11 , e21 ), . . . , (e1k , e2k )} | (end, ⊥)

The assertion (e+ , T ) denotes an event as used for typing an output. This is used to

ensure that assertion composition is well-defined wrt. the side conditions in the type

rules. The assertion un x{x1 , . . . , xk }(e+ , T ) records the set of names {x1 , . . . , xk } that

have already been used as shared channels and requires that the behaviour of the name

x that is now to be used as a shared channel must be typed in a type environment in

which every names have the following properties: It must be a shared channel, must

use event e, must communicate content of type T and cannot be one of the names in

{x1 , . . . , xk }. The matched(T ) predicate in the type rule for restriction corresponds to a

new assertion matched(T ).

Binary Session Types for Psi-Calculi


Composition is defined by a collection of axioms; these include

lin x{x1 , . . . , xk }e

{x1 , . . . , xk } ≺1

{x, x1 , . . . , xk } ≺ = {x1 , . . . , xk }(e+ ≺) if e ∈≺



{x1 , . . . , xk } ≺2 = {x1 , . . . , xk } ≺1 ∪ ≺2

The representation of processes is homomorphic except for restriction, where we must

add the condition that the type of x must be matched.

(ν x : T )P = (ν x : T )(matched(T ) | P )

In the representation of the type system the type judgements of the original system

of the form Γ ; ≺ P appear as judgments Γ ; Ψ≺ P where Ψ≺ is the assertion that

represents the strict partial order ≺.

We here show one of the type rules for typing names; note how assertions are used

to guide typability together with the generic rule for typing input processes.

(L IN -NAME -I N ) x : e lin?T.L, lin x{x1 , . . . , xk }e

x : elin? T.L

Vieira and Vasconcelos provide transition relations for type environments and for

strict partial ordering. Assuming these, they prove

Theorem 12 ([24]). If Γ1 ; ≺1 P1 and P1 → P2 then Γ1 ; ≺1 → Γ2 ; ≺2 with Γ2 ; ≺2 P2

This theorem follows directly from Theorem 10 for our generic type system, since

our transition relation on types corresponds to that of the original type system and since

the transition relation on spo’s is captured by the ordering relation ≤ on assertions.

The final theorem guarantees progress: a process P that is well-typed in a matched

type environment (i.e. a Γ where matched(T ) for every x ∈ dom(Γ ), where Γ (x) = T )

and has a communication prefix available (written active(P)), can always perform a

communication. However, the progress result

Theorem 13 ([24]). If active(P) and Γ ; ≺ P and matched(Γ ), P → P for some P .

must still be established separately since this is a property of the specific instance.

7.3 Refinement Types

In [1], Baltazar et al. describe a π -calculus with refinement types that generalizes the the

correspondence type systems introduced by Gordon and Jeffrey [15] and later extended

by Fournet et al. to include formulae in a fragment of first-order logic [10].

The idea is to annotate processes with correspondence assertions that are formulae

from a multiplicative fragment of linear logic. The syntax of the calculus is given by

ϕ ::= A(v) | ϕ1 ϕ2 | 1

P ::= x(y).P1 | x v .P1 | P1 | P2 | ! P | 0 | (ν xy : T )P1 | (assume ϕ )P | assert ϕ .P

The restriction (ν xy : T )P1 declares two endpoints of a session channel whose scope is

P1 . Values v can be either names x or the null value ().


H. Hăuttel

assert and assume are the correspondence assertions. In the reduction semantics, an assert ϕ can only be passed if the assertion ϕ has been assumed previously:

(assume ϕ )(assert ϕ .P | Q) → P | Q

A process is safe if every assertion will be met by an assumption. Only communications

involving bound endpoints are allowed. This can be seen from the following reduction

rule that also states how endpoint types evolve. Here the q denotes (as in the previous

type system) if a type is linear (lin) or unrestricted (un).

(ν xy : (q!w : T.U))(x v .P | y(z).Q | R) → (ν xy : U[v/w])(P | Q[v/z] | R)


The types in the system are given by the formation rules

T :: = unit | end | q p | {x : T | ϕ } | α | μα .T

q :: = lin | un

p :: =?x : T1 .T2 |!x : T1 .T2

A session type p is a dependent type; it can be a refinement type {x : T | ϕ }. Types T

can be recursive types of the form μα .T where α is a recursion variable.

Type environments may contain formulae:

Γ :: = · | Γ , x : T | Γ , ϕ

A formula is well-formed in Γ , written Γ wf ϕ if all its variables belong to dom(Γ ).

A type environment is unlimited, written un(Γ ) if for every x ∈ dom(Γ ) we have that

Γ (x) = un p for some p. The splitting rules for type environments Γ are similar to those

of the type system for progress and are omitted here.

Two of the most interesting type rules are given below. In (T-R EF E) we type a

refinement assertion by adding a type assumption for the name in the abstraction type

and instantiating it. (T-O UT ) is a rule for name-dependent session types. When typing

the suffix of a communication, the remaining session type must be instantiated with the

name that was communicated.

(T-R EF E)

(T-O UT )

Γ1 , x : T, ϕ [x/y], Γ2 P

Γ1 , x : {y : T | ϕ }, Γ2 P


x : (q!y : T.U) Γ2 v : T Γ3 + x : U[v/y]

Γ1 ◦ Γ2 ◦ Γ3 x v .P


Most of the representation of the process calculus as a psi-calculus is straightforward. A restriction (ν xy : T )P1 introduces two nullary session constructors x and y for

which we have that x ↔

˙ y. We represent assume ϕ ’s as assertions; to indicate their scope

every assertion is associated with a fresh name as follows.

(assume ϕ )P = (ν c)(ϕ @c | P )

where c ∈

/ n(P) ∪ n(ϕ ) and define the satisfaction relation as ϕ @c |= ϕ for any c.

Binary Session Types for Psi-Calculi


We encode an assert ϕ using the case construct


assert ϕ .P = case ϕ P

Type judgements Γ P are represented as ΓΓ , ΨΓ P where ΓΓ is the collection of

type bindings in Γ and ΨΓ is the composition of the assertions in Γ .

The transition relation for types is defined as follows.

?T (y)

q ?x : T1 .T2 −−−→ T2 [y/x]

for every y

!T (y)

q !x : T1 .T2 −−−→ T2 [y/x]

for every y

The original type system satisfies the subject reduction property.

Theorem 14 ([1]). If Γ

P and P → P then Γ


It may be surprising that this result is captured by Theorem 10. However, Γ only

records the types of free names, and names involved in a reduction are bound according

to (3). Moreover, for this particular psi-calculus instance, assertions corresponding to

formulae do not disappear along a reduction, so the assertions needed to type the resulting component must be identical for it to be well-typed. On the other hand, the safety

result for well-typed processes must be established separately.

8 Conclusions and Future Work

In this paper we have presented a generic type system capable of capturing existing

session type systems in the setting of psi-calculi. Our type system satisfies a fidelity

property that carries over to specific instances that satisfy certain natural requirements.

A crucial aspect of the generic type system is its ability to use assertions to represent concrete instances. Assertions in the original psi-calculus framework were mostly

thought of as related to the operational semantics, but the work in this paper demonstrates that assertions provide us with the necessary means of controlling typability.

A challenge is to be able to give a general account of the safety properties considered

in the instances studied in this paper, such that the type safety properties of instances

follow from a general theorem about well-typed processes. As the generic type system

can be instantiated both to type systems for safety properties such as that of [1] and

liveness properties such as that of [24], a general theorem of this kind will probably

require a classification of the properties of the assertions that can be used in a particular

type system instance.

A future goal is to show how to express the linear type system for psi-calculi of [20]

in the session type system and vice versa. In the setting of π -calculus, a translation from

session types to linear types was hinted at by Kobayashi and later carried out by Dardha

et al. [8]. An encoding along these lines will probably take the form of a translation

P Ψ where Ψ is an assertion that ‘renames’ the channel object to a fresh name.

Further work involves dealing with behavioural type systems in which the types

of an arbitrary number of names are modified as the result of performing a labelled

transition. This includes the systems for deadlock prevention due to Kobayashi [22].


H. Hăuttel

In the present work, our notion of duality is the original one from [18]. However,

other notions of duality have recently been proposed [4] and a natural next step is to

capture these in a general setting. If our treatment is extended to a higher-order setting,

a new treatment of duality will also be necessary [3].

Acknowledgements. The author would like to thank Johannes Borgstrăom and Bjăorn Victor for

useful comments and suggestions. The work was supported by the COST Action IC1021 BETTY.


1. Baltazar, P., Mostrous, D., Vasconcelos, V.T.: Linearly refined session types. In: LINEARITY, pp. 38–49 (2012)

2. Bengtson, J., Johansson, M., Parrow, J., Victor, B.: psi-calculi: a framework for mobile

processes with nominal data and logic. Logical Methods Comput. Sci. 7(1) (2011)

3. Bernardi, G., Hennessy, M.: Using higher-order contracts to model session types (Extended

Abstract). In: Baldan, P., Gorla, D. (eds.) CONCUR 2014. LNCS, vol. 8704, pp. 387–401.

Springer, Heidelberg (2014). doi:10.1007/978-3-662-44584-6 27

4. Bernardi, G., Dardha, O., Gay, S.J., Kouzapas, D.: On duality relations for session types. In:

Maffei, M., Tuosto, E. (eds.) TGC 2014. LNCS, vol. 8902, pp. 51–66. Springer, Heidelberg

(2014). doi:10.1007/978-3-662-45917-1 4

˚ A sorted semantic frame5. Borgstrăom, J., Gutkovas, R., Parrow, J., Victor, B., Pohjola, J.A.:

work for applied process calculi (Extended Abstract). In: Abadi, M., Lluch Lafuente, A.

(eds.) TGC 2013. LNCS, vol. 8358, pp. 103–118. Springer, Heidelberg (2014). doi:10.1007/

978-3-319-05119-2 7

6. Castagna, G., Dezani-Ciancaglini, M., Giachino, E., Padovani, L.: Foundations of session

types. In: PPDP, pp. 219–230. ACM (2009)

7. Castagna, G., Gesbert, N., Padovani, L.: A theory of contracts for web services. ACM Trans.

Program. Lang. Syst. 31(5), 19: 1–19: 61 (2009)

8. Dardha, O., Giachino, E., Sangiorgi, D.: Session types revisited. In: Proceedings of the 14th

Symposium on Principles and Practice of Declarative Programming, PPDP 2012, pp. 139–

150. ACM, New York (2012)

9. Dezani-Ciancaglini, M., de’Liguoro, U., Yoshida, N.: On progress for structured communications. In: Barthe, G., Fournet, C. (eds.) TGC 2007. LNCS, vol. 4912, pp. 257–275.

Springer, Heidelberg (2008). doi:10.1007/978-3-540-78663-4 18

10. Fournet, C., Gordon, A.D., Maffeis, S.: A type discipline for authorization policies. ACM

Trans. Program. Lang. Syst., 29(5) (2007)

11. Gabbay, M.J., Mathijssen, A.: Nominal (universal) algebra: equational logic with names and

binding. J. Log. Comput. 19(6), 1455–1508 (2009)

12. Gay, S.J.: Bounded polymorphism in session types. Math. Struct. Comput. Sci. 18(5), 895–

930 (2008)

13. Gay, S.J., Hole, M.: Subtyping for session types in the pi calculus. Acta Inf. 42(2–3), 191–

225 (2005)

14. Giunti, M., Vasconcelos, V.T.: A linear account of session types in the pi calculus. In: Gastin,

P., Laroussinie, F. (eds.) CONCUR 2010. LNCS, vol. 6269, pp. 432–446. Springer, Heidelberg (2010). doi:10.1007/978-3-642-15375-4 30

15. Gordon, A.D., Jeffrey, A.: Authenticity by typing for security protocols. J. Comput. Secur.

11(4), 451–519 (2003)

16. Honda, K.: Types for dyadic interaction. In: Best, E. (ed.) CONCUR 1993. LNCS, vol. 715,

pp. 509–523. Springer, Heidelberg (1993). doi:10.1007/3-540-57208-2 35

Binary Session Types for Psi-Calculi


17. Honda, K.: Composing processes. In: POPL, pp. 344–357 (1996)

18. Honda, K., Vasconcelos, V.T., Kubo, M.: Language primitives and type discipline for structured communication-based programming. In: Hankin, C. (ed.) ESOP 1998. LNCS, vol.

1381, pp. 122138. Springer, Heidelberg (1998). doi:10.1007/BFb0053567

19. Hăuttel, H.: Typed -calculi. In: Katoen, J.-P., Kăonig, B. (eds.) CONCUR 2011. LNCS, vol.

6901, pp. 265279. Springer, Heidelberg (2011). doi:10.1007/978-3-642-23217-6 18

20. Hăuttel, H.: Types for resources in ψ -calculi. In: Abadi, M., Lluch Lafuente, A. (eds.)

TGC 2013. LNCS, vol. 8358, pp. 83–102. Springer, Heidelberg (2014). doi:10.1007/

978-3-319-05119-2 6

21. Igarashi, A., Kobayashi, N.: A generic type system for the Pi-calculus. Theoret. Comput. Sci.

311(1–3), 121–163 (2004)

22. Kobayashi, N.: A new type system for deadlock-free processes. In: Baier, C., Hermanns, H.

(eds.) CONCUR 2006. LNCS, vol. 4137, pp. 233247. Springer, Heidelberg (2006). doi:10.

1007/11817949 16

23. Kăonig, B.: Analysing input/output-capabilities of mobile processes with a generic type system. J. Logic Algebraic Program. 63(1), 35–58 (2005)

24. Torres Vieira, H., Thudichum Vasconcelos, V.: Typing progress in communication-centred

systems. In: Nicola, R., Julien, C. (eds.) COORDINATION 2013. LNCS, vol. 7890, pp. 236–

250. Springer, Heidelberg (2013). doi:10.1007/978-3-642-38493-6 17

Tài liệu bạn tìm kiếm đã sẵn sàng tải về

3 Type Rules for Terms, Assertions and Conditions

Tải bản đầy đủ ngay(0 tr)