3 Type Rules for Terms, Assertions and Conditions
Tải bản đầy đủ - 0trang
Binary Session Types for Psi-Calculi
105
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
otherwise
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:
!U
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).
?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 Γ , Ψ
,l
M : T @c and T −−→ T then Γ , Ψ
M
l : (T @c, ).
2
KN :
106
H. Hăuttel
Table 3. Psi-calculus type rules
,l
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 Γ , Ψ
minimal.
min
107
α : (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 ∈
/
!T
?T
1
1
T1 and T −−→
T2 , we let
b ∪ dom(Γ ) and T −→
def
Γ ± (ν a)τ @(ν b)(M N K : (T @c, T1 )) = Γ + c : (T1 , T2 )
2. If Γ1 , Ψ1
τ @(ν a)(M
l
,l
K) : (T @c, •) and Γ = Γ + c : (T , T ) with c ∈
/
,l
a, dom(Γ ) and T −−→ T1 and T −−→ T2 , we let
Γ ± τ @(ν a)(M
l
def
K) : (T @c, •) = Γ + c : (T1 , T2 )
Lemma 8 (Well-typed observable actions). Suppose we have Ψ0
Γ , Ψ P with Ψ ≤ Ψ0 . Then
α
P−
→ 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
α
→P.
now proceeds by induction in the proof tree for the transition 0 P
108
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 ⇐⇒ Γ
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.
7.1
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
def
? T1 .T2 = ! T1 .T2
def
& l1 : S1 , . . . , lk : Sk = ⊕ l1 : S1 , . . . , lk : Sk
def
def
! T1 .T2 = ? T1 .T2
def
def
μ 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 )
?T
1
? T1 .T2 −−→
T2
(S-O UT )
l
i
(S-B RANCH ) & l1 : S1 , . . . , lk : Sk −−→
Si (S-S ELECT )
!T
1
! T1 .T2 −−→
T2
l
i
l1 : S1 , . . . , lk : Sk −−→
Si
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
109
Definition 11. A type simulation is a binary relation R on types which satisfies that
whenever (T,U) ∈ R we have
!T
!U
?T
?U
1
1
1. If T −→
T2 then U −−→
U2 with (U1 , T1 ) ∈ R and (T2 ,U2 ) ∈ R
1
1
T2 then U −−→
U2 with (T1 ,U1 ) ∈ R and (T2 ,U2 ) ∈ R
2. If T −−→
k
k
3. If U −−→ U1 then T −−→ T1 with (T1 ,U1 ) ∈ R
k
k
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(−).
(S UBSUME )
Γ ,Ψ M : T T ≤ T
Γ ,Ψ M : T
(L OOKUP ) Γ , Ψ
(S ESSION+) Γ , Ψ
(S ESSION−) Γ , Ψ
if Γ (n) = T
if Γ (c) = Unit → T
if Γ (c) = Unit → T
n: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 ↓)
def
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
110
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, ⊥)}
0
Γ , 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
!T
!T
?T
?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
111
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 ().
112
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)
(3)
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
Γ1
x : (q!y : T.U) Γ2 v : T Γ3 + x : U[v/y]
Γ1 ◦ Γ2 ◦ Γ3 x v .P
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
113
We encode an assert ϕ using the case construct
def
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 Γ
P.
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].
114
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.
References
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
115
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