Operational and Denotational Semantics for Classical Processes - - PowerPoint PPT Presentation

Operational and Denotational Semantics for Classical Processes

Robert Atkey University of Strathclyde, Glasgow robert.atkey@strath.ac.uk 6th January 2017

Girard/Abramsky, early 90s: (Linear Logic) Proofs as Processes

▶ Processes realise proofs ▶ Process reductions in lock-step with Cut-reduction ▶ Not a completely neat fit (Bellin, Scott, 1994) ▶ Fruitful idea: GoI, Interaction Categories, Game Semantics, ...

Caires, Pfenning: Intuitionistic Linear Logic and Session Types

▶ Assign proof terms to DILL proofs ▶ Careful “channel management”: propositions as sessions ▶ (Wadler, 2012) Classical LL version: CP

Damiano Mazza, The True Concurrency of Differential Interaction Nets, 2015. However, although linear logic has kept providing, even in recent times, useful tools for ensuring properties of process algebras, especially via type systems (Kobayashi et al., 1999; Yoshida et al., 2004; Caires and Pfenning, 2010; Honda and Laurent, 2010), all further investigations have failed to bring any deep logical insight into concurrency theory, in the sense that no concurrent primitive has found a convincing counterpart in linear logic, or anything even remotely resembling the perfect correspondence between functional languages and intuitionistic

• logic. In our opinion, we must simply accept that linear

logic is not the right framework for carrying out Abramsky’s “proofs as processes” program (which, in fact, more than 20 years after its inception has yet to see a satisfactory completion).

My Goal: What is the observable result of a CP process?

▶ An Operational Semantics ▶ A notion of “observed behaviour” ▶ A notion of “observational equivalence” ▶ A denotational semantics with an adequacy proof

Wadler’s “Classical Processes”

(a term language for Girard’s Classical Linear Logic)

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A ⊥lp A ` B A & B ?A

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A positive ⊥lp A ` B A & B ?A

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A positive ⊥lp A ` B A & B ?A negative

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A positive ⊥lp A ` B A & B ?A negative

• multiplicative

additive

• exponentials

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A

• utput

⊥lp A ` B A & B ?A negative

• multiplicative

additive

• exponentials

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A

• utput

⊥lp A ` B A & B ?A input

• multiplicative

additive

• exponentials

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A

• utput

⊥lp A ` B A & B ?A input

• topology

additive

• exponentials

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A

• utput

⊥lp A ` B A & B ?A input

• topology

data

• exponentials

Propositions as Sessions

A, B ::= 1lp A ⊗ B A ⊕ B !A

• utput

⊥lp A ` B A & B ?A input

• topology

data

• lpservers

Propositions as Sessions

Output a choice: Bit = 1 ⊕ 1 Input a choice: Bit⊥ = ⊥ & ⊥

Propositions as Sessions

Duality flips input and output: 1⊥ = ⊥ ⊥⊥ = 1 (A ⊗ B)⊥ = A⊥ ` B⊥ (A ` B)⊥ = A⊥ ⊗ B⊥ (A ⊕ B)⊥ = A⊥ & B⊥ (A & B)⊥ = A⊥ ⊕ B⊥ (!A)⊥ = ?A⊥ (?A)⊥ = !A⊥

Propositions as Sessions

Receive two bits and return a bit: Server = !(Bit⊥ ` Bit⊥ ` Bit ⊗ 1) Emit two bits and receive a bit: Client = Server⊥ = ?(Bit ⊗ Bit ⊗ Bit⊥ ` ⊥) Another way of writing Server, using A B A B: Server ! Bit Bit Bit

Propositions as Sessions

Receive two bits and return a bit: Server = !(Bit⊥ ` Bit⊥ ` Bit ⊗ 1) Emit two bits and receive a bit: Client = Server⊥ = ?(Bit ⊗ Bit ⊗ Bit⊥ ` ⊥) Another way of writing Server, using A ⊸ B = A⊥ ` B: Server = !(Bit ⊸ Bit ⊸ Bit ⊗ 1)

Processes as Proofs

⊢ P :: x1 : A1, . . . , xn : An

• unconnected channels

Processes as Proofs

Structural ⊢ x ↔ y :: x : A, y : A⊥ (Ax) ⊢ P :: Γ, x : A ⊢ Q :: ∆, x : A⊥ ⊢ νx.(P|Q) :: Γ, ∆

(Cut)

⊢ 0 ::

(Mix0)

Processes as Proofs

Multiplicative ⊢ x[] :: x : 1

(1)

⊢ P :: Γ ⊢ x().P :: Γ, x : ⊥

(⊥)

⊢ P :: Γ, y : A ⊢ Q :: ∆, x : B ⊢ x[y].(P|Q) :: Γ, ∆, x : A ⊗ B

(⊗)

⊢ P :: Γ, y : A, x : B ⊢ x(y).P :: Γ, x : A ` B

(`)

Processes as Proofs

Additive ⊢ P :: Γ, x : Ai ⊢ x[i].P :: Γ, x : A0 ⊕ A1

(⊕i)

⊢ P :: Γ, x : A0 ⊢ Q :: Γ, x : A1 ⊢ x.case(P, Q) :: Γ, x : A0 & A1

(&)

Processes as Proofs

Exponential ⊢ P :: ?Γ, y : A ⊢ !x[y].P :: ?Γ, x : !A

(!)

⊢ P :: Γ, y : A ⊢ ?x(y).P :: Γ, x : ?A

(?)

⊢ P :: Γ, x1 : ?A, x2 : ?A ⊢ P{x1/x2} :: Γ, x1 : ?A

(C)

⊢ P :: Γ ⊢ P :: Γ, x : ?A

(W)

Processes as Proofs

Some syntactic sugar: x[0].P

def

= x[y].(y[0].y[] | P) x[1].P

def

= x[y].(y[1].y[] | P) case x.{0 → P; 1 → Q}

def

= x.case(x().P, x().Q) An “AND” server: !x y y p y q case p case q 0 y 0 y 1 y 0 y 1 case q 0 y 0 y 1 y 1 y x Server A binary binary operation client: ?x y y 1 y 1 case y 0 y 1 y x Client

Processes as Proofs

Some syntactic sugar: x[0].P

def

= x[y].(y[0].y[] | P) x[1].P

def

= x[y].(y[1].y[] | P) case x.{0 → P; 1 → Q}

def

= x.case(x().P, x().Q) An “AND” server: ⊢ !x[y].y(p).y(q).case p.{ 0 → case q.{0 → y[0].y[]; 1 → y[0].y[]}; 1 → case q.{0 → y[0].y[]; 1 → y[1].y[]}} :: x : Server A binary binary operation client: ?x y y 1 y 1 case y 0 y 1 y x Client

Processes as Proofs

Some syntactic sugar: x[0].P

def

= x[y].(y[0].y[] | P) x[1].P

def

= x[y].(y[1].y[] | P) case x.{0 → P; 1 → Q}

def

= x.case(x().P, x().Q) An “AND” server: ⊢ !x[y].y(p).y(q).case p.{ 0 → case q.{0 → y[0].y[]; 1 → y[0].y[]}; 1 → case q.{0 → y[0].y[]; 1 → y[1].y[]}} :: x : Server A binary binary operation client: ⊢ ?x(y).y[1].y[1].case y.{0 → y().0; 1 → y().0} :: x : Client

Dynamics of Classical Processes

(Cut-Elimination?)

Cut-Elimination as Execution

Two processes: ⊢ P :: Γ, x : A ⊢ Q :: ∆, x : A⊥ Joined by a Cut: P x A Q x A x P Q

Cut-Elimination as Execution

Two processes: ⊢ P :: Γ, x : A ⊢ Q :: ∆, x : A⊥ Joined by a Cut: ⊢ P :: Γ, x : A ⊢ Q :: ∆, x : A⊥ ⊢ νx.(P | Q) :: Γ, ∆

Cut-Elimination as Execution

. . . ⊢ P :: Γ, x : Ai ⊢ x[i].P :: Γ, x : A0 ⊕ Ai . . . ⊢ Q0 :: ∆, x : A⊥ . . . ⊢ Q1 :: ∆, x : A⊥

1

⊢ x.case(Q0, Q1) :: ∆, x : A⊥

0 & A⊥ 1

⊢ νx.(x[i].P | x.case(Q0, Q1)) :: Γ, ∆

(Cut)

Cut-elimination yields...

. . . P x Ai . . . Qi x Ai x P Qi (the proof tree has become smaller, and data was moved)

Cut-Elimination as Execution

. . . ⊢ P :: Γ, x : Ai ⊢ x[i].P :: Γ, x : A0 ⊕ Ai . . . ⊢ Q0 :: ∆, x : A⊥ . . . ⊢ Q1 :: ∆, x : A⊥

1

⊢ x.case(Q0, Q1) :: ∆, x : A⊥

0 & A⊥ 1

⊢ νx.(x[i].P | x.case(Q0, Q1)) :: Γ, ∆

(Cut)

Cut-elimination yields...

. . . ⊢ P :: Γ, x : Ai . . . ⊢ Qi :: ∆, x : A⊥

i

⊢ νx.(P | Qi) :: Γ, ∆ (the proof tree has become smaller, and data was moved)

Cut-Elimination as Execution

Orientation of Principal Cuts as Reductions: νx.(x[] | x().P) − → P νx.(x[y].(P|Q) | R) − → νy.(P | νx.(Q | R)) νx.(x[i].P | x.case(Q0, Q1)) − → νx.(P | Qi) νx.(!x[y].P | ?x(y).Q) − → νy.(P | Q) νx.(!x[y].P | Q{x/x′}) − → νx.(!x[y].P | νx′.(!x′[y].P | Q)) νx.(!x[y].P | Q) − → Q

Cut-Elimination as Execution

What if we are stuck? νz.(x().P | Q)

Cut-Elimination as Execution

What if we are stuck? νz.(x().P | Q) − → x().νz.(P|Q) νz.(x[y].(P|Q) | R) − → x[y].(νz.(P | R) | Q) νz.(x[y].(P|Q) | R) − → x[y].(P | νz.(Q | R)) νz.(x(y).P | Q) − → x(y).νz.(P | Q) νz.(x[i].P | Q) − → x[i].νz.(P | Q) νz.(x.case(P, Q) | R) − → x.case(νz.(P | R), νz.(Q | R)) νz.(!x[y].P | Q) − → !x[y].νz.(P | Q) νz.(?x(y).P | Q) − → ?x(y).νz.(P | Q)

Cut-Elimination as Execution

A problem: νx.(y[0].x[1].P | z[0].x.case(Q0, Q1)) y[0].z[0].νx.(x[1] | x.case(Q0, Q1)) z[0].y[0].νx.(x[1] | x.case(Q0, Q1)) Ought we equate: y z x x x case Q Q and z y x x x case Q Q

Cut-Elimination as Execution

A problem: νx.(y[0].x[1].P | z[0].x.case(Q0, Q1)) y[0].z[0].νx.(x[1] | x.case(Q0, Q1)) z[0].y[0].νx.(x[1] | x.case(Q0, Q1)) Ought we equate: y[0].z[0].νx.(x[1] | x.case(Q0, Q1)) and z[0].y[0].νx.(x[1] | x.case(Q0, Q1))

Cut-Elimination as Execution?

If we equate:

▶ Reduction modulo? ▶ Proof nets/Interaction nets? ▶ Still need commuting conversions...

Restrict to one output channel? Approach by Pérez, Caires, Pfenning, Toninho In an intuitionistic (single conclusion) setting Define an LTS over processes with a single free channel Seems ad-hoc in a classical (multiple conclusion) setting Is there a “nice” LTS semantics of CP? (I don’t know!)

Cut-Elimination as Execution?

If we equate:

▶ Reduction modulo? ▶ Proof nets/Interaction nets? ▶ Still need commuting conversions...

Restrict to one output channel?

▶ Approach by Pérez, Caires, Pfenning, Toninho ▶ In an intuitionistic (single conclusion) setting ▶ Define an LTS over processes with a single free channel ▶ Seems ad-hoc in a classical (multiple conclusion) setting ▶ Is there a “nice” LTS semantics of CP? (I don’t know!)

Observed Communication Semantics

Configurations

⊢c C :: Γ

• unconnected channels

| Θ

• connected channels

Connected channels are “up to duality”

c C

x A xn An is same as

c C

x A xn An

Configurations

⊢c C :: Γ

• unconnected channels

| Θ

• connected channels

Connected channels are “up to duality” ⊢c C :: Γ | x1 : A1, . . . , xn : An is same as ⊢c C :: Γ | x1 : A⊥

1 , . . . , xn : A⊥ n

Configurations

⊢ P :: Γ ⊢c P :: Γ | ·

(cfgProc)

⊢c 0 :: · | ·

(cfg0)

⊢c C1 :: Γ1, x : A | Θ1 ⊢c C2 : Γ2, x : A⊥ | Θ2 ⊢c C1 |x C2 :: Γ1, Γ2 | Θ1, Θ2, x : A

(cfgCut)

⊢c C :: Γ | Θ ⊢c C :: Γ, x : ?A | Θ

(cfgW)

⊢c C :: Γ, x1 : ?A, x2 : ?A | Θ ⊢c C{x1/x2} :: Γ, x1 : ?A | Θ

(cfgC)

Configurations

Connecting the “AND” Server and Client: ⊢c ServerP |x ClientP :: · | x : Server Equivalent typing ⊢c ServerP |x ClientP :: · | x : Client

Observations

1 = ⊥ = {∗} A ⊗ B = A ` B = A × B A0 ⊕ A1 = A0 & A1 = Σi∈{0,1}. Ai !A = ?A = Mf(A)

Observed Communication Semantics

For a closed configuration ⊢c C :: · | Θ Evaluation assigns observations: C ⇓ θ

where θ ∈ Θ

Observed Communication Semantics

⊢c ServerP |x ClientP :: · | x : Server (ServerP |x ClientP) ⇓ (((1, ∗), (1, ∗), (1, ∗), ∗))

Observed Communication Semantics

Structural 0 ⇓ ()

(Stop)

C[C′{x/y}] ⇓ θ[x → a] C[x ↔ y |y C′] ⇓ θ[x → a, y → a]

(Link)

C[P |x Q] ⇓ θ[x → a] C[νx.(P|Q)] ⇓ θ

(Comm)

C′ ⇓ θ C ≡ C′ C ⇓ θ

(≡)

C[0] ⇓ θ C[0] ⇓ θ

(0)

Observed Communication Semantics

Multiplicative (Topology) C[P] ⇓ θ C[x[] |x x().P] ⇓ θ[x → ∗]

(1⊥)

C[P |y (Q |x R)] ⇓ θ[x → a, y → b] C[x[y].(P|Q) |x x(y).R] ⇓ θ[x → (a, b)]

(⊗`)

Observed Communication Semantics

Additive (Data) C[P |x Qi] ⇓ θ[x → a] C[x[i].P |x x.case(Q0, Q1)] ⇓ θ[x → (i, a)]

(⊕&)

Observed Communication Semantics

Exponentials (Servers) C[P |y Q] ⇓ θ[y → a] C[!x[y].P |x ?x(y).Q] ⇓ θ[x → a]

(!?)

C[C′] ⇓ θ C[!x[y].P |x C′] ⇓ θ[x → ∅]

(!W)

C[!x1[y].P |x1 (!x2[y].P |x2 C′)] ⇓ θ[x1 → α, x2 → β] C[!x1[y].P |x1 C′{x1/x2}] ⇓ θ[x1 → α ⊎ β]

(!C)

Observational Equivalence

Observational Equivalence

⊢ P1 ≃ P2 :: Γ whenever, for all CP[−] such that ⊢c CP[P1] :: · | Θ ⊢c CP[P2] :: · | Θ then ∀θ. CP[P1] ⇓ θ ⇔ CP[P2] ⇓ θ

Denotational Semantics

(for reasoning about observational equivalence) (with the standard relational semantics of CLL)

Semantics of Propositions

1 = ⊥ = {∗} A ⊗ B = A ` B = A × B A0 ⊕ A1 = A0 & A1 = Σi∈{0,1}. Ai !A = ?A = Mf(A) with Γ = x1 : A1, . . . , xn : An = A1 × · · · × An

Semantics of Processes

⊢ P :: Γ ⊆ Γ (The standard relational semantics of CLL proofs)

Semantics of Processes

Structural ⊢ x ↔ y :: x : A, y : A⊥ = {(a, a) | a ∈ A} ⊢ νx.(P|Q) :: Γ, ∆ = {(γ, δ) | (γ, a) ∈ ⊢ P :: Γ, x : A, (δ, a) ∈ ⊢ Q :: ∆, x : A⊥} ⊢ 0 :: = {∗}

Semantics of Processes

Multiplicative ⊢ x[] :: x : 1 = {(∗)} ⊢ x().P :: Γ, x : ⊥ = {(γ, ∗) | γ ∈ ⊢ P :: Γ} ⊢ x[y].(P|Q) :: Γ, ∆, x : A ⊗ B = {(γ, δ, (a, b)) | (γ, a) ∈ ⊢ P :: Γ, y : A, (δ, b) ∈ ⊢ Q :: ∆, x : B} ⊢ x(y).P :: Γ, x : A ` B = {(γ, (a, b)) | (γ, a, b) ∈ ⊢ P :: Γ, y : A, x : B}

Semantics of Processes

Additive ⊢ x[i].P :: Γ, x : A0 ⊕ A1 = {(γ, (i, a)) | (γ, a) ∈ ⊢ P :: Γ, x : Ai} ⊢ x.case(P0, P1) :: Γ, x : A0 & A1 = ∪

i∈{0,1}{(γ, (i, a)) | (γ, a) ∈ ⊢ Pi :: Γ, x : Ai}

Semantics of Processes

Exponentials ⊢ !x[y].P :: ?Γ, x : !A = {(⊎k

j=1 α1 j , . . . , ⊎k j=1 αn j , a1, . . . , ak) |

∀i ∈ {1, . . . , k}. (α1

i , . . . , αn i , ai) ∈ ⊢ P :: ?Γ, y : A}

⊢ ?x(y).P :: Γ, x : ?A = {(γ, a}) | (γ, a) ∈ ⊢ P :: Γ, y : A} ⊢ P{x1/x2} :: Γ, x1 : ?A = {(γ, α1 ⊎ α2) | (γ, α1, α2) ∈ ⊢ P :: Γ, x1 : ?A, x2 : ?A} ⊢ P :: Γ, x : ?A = {(γ, ∅) | γ ∈ ⊢ P :: Γ}

Semantics of Processes

ServerP = {a1, . . . , ak | ∀i.ai ∈ S} where S = {((b1, ∗), (b2, ∗), (b1 ∧ b2, ∗), ∗) | b1 ∈ {0, 1}, b2 ∈ {0, 1}} ClientP b b

Semantics of Processes

ServerP = {a1, . . . , ak | ∀i.ai ∈ S} where S = {((b1, ∗), (b2, ∗), (b1 ∧ b2, ∗), ∗) | b1 ∈ {0, 1}, b2 ∈ {0, 1}} ClientP = {((1, ∗), (1, ∗), (b, ∗), ∗) | b ∈ {0, 1}}

Semantics of Configurations

⊢c 0 :: · | · = {(∗, ∗)} ⊢c P :: Γ | · = {(γ, ∗) | γ ∈ ⊢ P :: Γ} ⊢c C1 |x C2 :: Γ1, Γ2 | Θ1, Θ2, x : A = {((γ1, γ2), (θ1, θ2, a)) | ((γ1, a), θ1) ∈ ⊢c C1 :: Γ1, x : A | Θ1, ((γ2, a), θ2) ∈ ⊢c C2 :: Γ2, x : A⊥ | Θ2} ⊢c C :: Γ, x : ?A | Θ = {((γ, ∅), θ) | (γ, θ) ∈ ⊢c C :: Γ | Θ} ⊢c C{x1/x2} :: Γ, x1 : ?A | Θ = {((γ, a1 ⊎ a2), θ) | ((γ, a1, a2), θ) ∈ ⊢c C :: Γ, x1 : ?A, x2 : ?A | Θ}

Semantics of Configurations

⊢c ServerP |x ClientP :: · | x :: Server = {((1, ∗), (1, ∗), (1, ∗), ∗)} (Recall that ServerP x ClientP )

Semantics of Configurations

⊢c ServerP |x ClientP :: · | x :: Server = {((1, ∗), (1, ∗), (1, ∗), ∗)} (Recall that ServerP |x ClientP ⇓ (((1, ∗), (1, ∗), (1, ∗), ∗)) )

Adequacy

Adequacy

If ⊢c C :: · | Θ, then C ⇓ θ ⇔ θ ∈ ⊢c C :: · | Θ

Adequacy

Forward direction: C ⇓ θ ⇒ θ ∈ ⊢c C :: · | Θ

(Straightforward induction on the derivation of C ⇓ θ)

Adequacy

Backwards direction: C ⇓ θ ⇐ θ ∈ ⊢c C :: · | Θ

(Harder: use a ⊥⊥-closed logical relation)

Reasoning about Observational Equivalence

If ⊢ P1, P2 :: Γ and P1 = P2 then ⊢ P1 ≃ P2 :: Γ

Cut-Elimination Rules are Observational Equivalences

⊢ P :: Γ, x : Ai ⊢ Q0 :: ∆, x : A⊥ ⊢ Q1 :: ∆, x : A⊥

1

⊢ νx.(x[i].P | x.case(Q0, Q1)) ≃ νx.(P|Qi) :: Γ, ∆ Proof: νx.(x[i].P | x.case(Q0, Q1)) = {(γ, δ) | (γ, (j, a)) ∈ x[i].P, (δ, (j, a)) ∈ c.case(Q0, Q1)} = {(γ, δ) | (γ, a) ∈ P, (δ, a) ∈ Qi} = νx.(P | Qi)

Prefix-permutation Rules are Obs. Equivalences

⊢ P :: Γ, x′ : A, y′ : B ⊢ x().x′(y′).P ≃ x′(y′).x().P :: Γ, x : ⊥, x′ : A ` B Proof: x().x′(y′).P = {(γ, ∗, (a, b)) | (γ, a, b) ∈ P} = x′(y′).x().P

(up to permutations of the context)

Prefix-permutation Rules

What to learn from equivalences like: x().x′(y′).P ≃ x′(y′).x().P

• 1. CP is highly constrained
• 2. Processes cannot compare notes on interaction with 3rd parties
• 3. Time is only observable by means of data transfer

Meh

More Precise Denotational Semantics

The Relational Semantics does not distinguish between I and O: A & B = A ⊕ B

“degenerate”

Want schemes for identifying “good” subsets P ∈ PX ⊆ P(Γ). Sets of subsets closed under orthogonality: (PX)⊥ = {β | ∀α ∈ PX. α ⊥ β} such that PX⊥⊥ = PX.

• 1. Girard’s coherence spaces

α ⊥ β ⇔ |α ∩ β| ≤ 1

• 2. Loader’s totality spaces

α ⊥ β ⇔ |α ∩ β| = 1

• 3. Ehrhard’s finiteness spaces

α ⊥ β ⇔ |α ∩ β| < ω Parameterise semantics by the nature of interaction

Dependent Session Types

The “obvious” thing to do: ∆, x : τ ⊢ A linprop ∆, x : τ ⊢ P :: Γ, c : A x ̸∈ fv(Γ) ∆ ⊢ c(x).P :: Γ, c : Πx:τ.A ∆, x : τ ⊢ A linprop ∆ ⊢ M : τ ∆ ⊢ P :: Γ, c : A{M/x} ∆ ⊢ c[M].P :: Γ, c : Σx:τ.A (Πx:τ.A)⊥ = Σx:τ.A⊥ Essentially: infinitary additives.

Session-Dependent Types

A more interesting approach: Types depend on observed traffic

(McBride, 2014)

∆ ⊢ A linprop ∆, x : |A| ⊢ B linprop ∆ ⊢ (x : A) ▷ B linprop |A| is the type of observations of single runs of sessions of type A

“Before” connectives

(x : A) ▷ B is a generalisation of Retoré’s “before” connective (A ▷ B)⊥ = A⊥ ▷ B⊥ Has a nice coherence space semantics. Seems to need sequents with partially ordered multisets: ⊢ P :: x1 : A1, x2, : A2, x3 : A3 [x1 x3, x1 x3] Retoré’s POMset logic (1997), generalised to dependent types. Admits an ‘ordered’ multicut rule (speculative!) ⊢ Γ, Σ[1] ⊢ ∆, Σ⊥[2] ⊢ Γ, ∆ when 1 and 2 are equal totally ordered on Σ(⊥).

Repeated Behaviour

Baelde’s rules for ν and µ: ⊢ Γ, S ⊢ F[S], S⊥ ⊢ Γ, νF

(ν)

⊢ Γ, F[µF] ⊢ Γ, µF

(µ)

Racy servers – for “tail-recursive” F: S F S S S F

( )

S F S S S F F

( )

F F F

( )

F

(D)

Repeated Behaviour

Baelde’s rules for ν and µ: ⊢ Γ, S ⊢ F[S], S⊥ ⊢ Γ, νF

(ν)

⊢ Γ, F[µF] ⊢ Γ, µF

(µ)

Racy servers – for “tail-recursive” F: ⊢ Γ, S ⊢ F[S], S⊥ ⊢ S⊥ ⊢ Γ, νF

(ν1)

⊢ Γ, S ⊢ F[S], S⊥ ⊢ S⊥ ⊢ Γ, νF, νF

(ν2)

⊢ Γ, F[µF] ⊢ Γ, µF

(µ)

⊢ Γ ⊢ Γ, µF

(D)

Damiano Mazza, The True Concurrency of Differential Interaction Nets, 2015. However, although linear logic has kept providing, even in recent times, useful tools for ensuring properties of process algebras, especially via type systems (Kobayashi et al., 1999; Yoshida et al., 2004; Caires and Pfenning, 2010; Honda and Laurent, 2010), all further investigations have failed to bring any deep logical insight into concurrency theory, in the sense that no concurrent primitive has found a convincing counterpart in linear logic, or anything even remotely resembling the perfect correspondence between functional languages and intuitionistic

• logic. In our opinion, we must simply accept that linear

logic is not the right framework for carrying out Abramsky’s “proofs as processes” program (which, in fact, more than 20 years after its inception has yet to see a satisfactory completion).

▶ Observed Communication Semantics for CP ▶ Adequacy for the relational semantics

(and coherence spaces semantics) Towards “full” Session-dependent session types...? Racy servers? Before connective, deadlock-free multicut? More precise denotational semantics?

▶ Observed Communication Semantics for CP ▶ Adequacy for the relational semantics

(and coherence spaces semantics)

▶ Towards “full” Session-dependent session types...? ▶ Racy servers? ▶ Before connective, deadlock-free multicut? ▶ More precise denotational semantics?