Explicit Fusions Philippa Gardner, Lucian Wischik MFCS 2000, Bratislava
what is an “explicit fusion”? void P (int &x, int &y) fun P x y = { x = x^y; ( x := !x xor !y; y = y^x; y := !y xor !x; x = x^y; x := !x xor !y } ); How does P behave? How does P behave in a context where x=y ? <x = y> j P We write: <x = y> j P f y ñ x g = <x = y> j P f x ñ y g =
why explicit fusions? • in real world • momentum of related work • simplify syntax • help implementation • can add explicit fusions to different calculi. For example: pi-F calculus • like pi but with explicit fusions • LTS, bisimulation • embeds pi, fusion calculi • full abstraction for fusion calc.
fusions in real world y x Computer Keyboard ( <x> j K ) @ ( <y> j C ) ñ <x = y> j K j C
fusions and substitutions internet socket x y socket P Q <x = y> j P j Q P f y x g j Q = alternative to substitution: “explicitly record and delay the effect of the fusion” cf. Explicit Substitutions [ACCL 91] explicit fusions - distributed virtual machine for pi-calculus .
related work 1 ccs pi. [MPW89] output u:<y>P u: ( x ) Q input ( ÷x ) P name-hiding P j Q f y u:<y>P j u: ( x ) Q & x g = cut-elim. as comm. conc. constraints power of int. mob . action calculi explicit fusions. [GW00] pi-I. [Sang96] fusion calculus. [VP98] u: ( y ) P; u: ( x ) Q chi calculus. [FU97] u: ( y ) P j u: ( x ) Q & ( ÷z )( P f z y g j Q f z u:<y>P; u:<x>Q x g ) = = z fresh u:<y>P j u:<x>Q & ???
pi-calculus • comm. between output, input u<y>:P j u ( x ) :Q & P j Q f y x g = • mobile scope of names/channels à á ( ÷y ) j u ( x ) :P u<y> à á ñ ( ÷y ) u<y> j u ( x ) :P • dynamic creation of names/channels concretions+abstractions [Mil99] u:<y>P • syntactic change: u; u • makes a commitment • effects sorted out by @ u:<y>P j u: ( x ) Q & <y>P @ ( x ) Q
related work 2 Categorical Framework Graphs Fusions Explicit Symmetric ACs [GW] Expl. Subs Fusion Systems [G00] pi-F [GW00] Equators [H95] Permutations [H] Process Graphs [Y94] Tiles [GM96]
pi-F calculus • grammar • reaction relation • structural congruence (e.g. alpha conversion) labels, bisimulation • to describe interaction with environment • to compare two processes without detail of internal state embedding pi, fusion • how to encode bound inp. • results: reaction preserved, full abstraction for fusion & not pi
pi-F calculus P ::= nil empty process P j P parallel composition ( ÷x ) P name-hiding datum <x> <x = y> explicit fusion x:P input x:P output datums explicit fusion • are like concretions • denotes an equivalence relation • polyadic, through parallel composition • finite basis • not commutative • has substitutive effect <x> j <y> j P á á á <xy>P
pi-F reaction u:P j u:Q & P @ Q u: ( <y> j P ) j u: ( ÷x )( <x> j Q ) & ( <y> j P ) @ ( ÷x )( <x> j Q ) à á ñ ( ÷x ) <x = y> j P j Q ñ P f y x g j Q f y x g = = effect of @ is to fuse datums • use standard form: dats, fus, restrictions (“interface”) factored out • interfaces are unique up to alpha-conversion <x> @ <y> ñ <x = y> • if datums, then explicit fusions. encode lazy input ( ÷x )( u:<x> j Q ) encode bound input u: ( x ) Q
struct.cong. rules for fusions ( ÷x )( x: nil ) ñ ( ÷x )( ÷y )( <x = y> j x: nil ) create fresh bound name y as alias for x ñ ( ÷x )( ÷y )( <x = y> j y: nil ) substitute y for x ñ ( ÷y )( y: nil ) remove the now-unused bound name x <x = y> j <y = z> ñ <x = y> j <x = z> transitivity symmetry <x = y> ñ <y = x> reflexivity <x = x> ñ nil ! <x = y> j z:P ñ <x = y> j z: ( <x = y> j P ) <x = y> j x:P ñ <x = y> j y:P and other small-step substitutions ( ÷x )( <x = y> ) ñ nil restriction delimits scope of fusion !
standard presentation • reaction relation & labelled transitions bisimulation labelled transitions u u ü • “commitment” labels ! ! ! ü & ! • corresponds to ø bisimulation relation • “ P can do all the transitions that Q can, and vice versa” • bisimulation is a congruence • It equals fusion-bisimulation, but not pi-open-bisimulation
pi-F labels, bisimulation u ü u u:P ! u:P j u:Q ! P @ Q P u:P ! P Bisimulation is standard, augmented for fusion contexts: a relation S is an open bisimulation iff whenever PSQ then ï P; Q have same interface (same datums, fusions, restrictions) ë P 1 then <x = y> j Q ! ë Q 1 and P 1 S Q 1 ï for all x; y; if <x = y> j P ! ï and vice versa To avoid the quantification, we add a fusion transition ? u = v u:P j v:Q à ! P @ Q
embedding pi and fusion piF pi u:<y>P j u: ( x ) Q & P j Q f y = x g fusion u:P j u:Q ( ÷x )( u:<x>P j u:<y>Q j R ) & P @ Q & P f y x g j Q f y x g j R f y x g ã = = = • Translations straightforward. (using bound-input encoding) • Both embeddings preserve structural congruence • Pi embedding preserves reaction relation • Fusion embedding weakly preserves reaction relation (must further constrain it, with same constraint *)
results pi-F bisimulation is a congruence. • proof: standard. create another LTS without struct. cong. rule P ø Q ) 8 C: C [ P ] ø C [ Q ] pi-F bisimulation equals fusion hyperequivalence • proof: fusion hyperequivalence is just pi-F bisim. without interfaces pi-F bisimulation is stronger than pi-open-bisimulation • “open” bisimulation [S96]: one that’s closed w.r.t subsitutions (or fusions) • proof: in example below, no pi context can make x=y ; but pi-F can. ( ÷xy )( u:<xy> j P )
ongoing work • (replication) • implementation based on explicit fusions • lambda calculus encoding, using datums to represent lambda variables • add explicit fusions to other calculi (“fusion systems”)
Recommend
More recommend
