Explicit Fusions Lucian Wischik (Cambridge) Bologna, October 2000 joint work with Philippa Gardner paper in proceedings of MFCS2000
what is an “explicit fusion”? void P (int &x, int &y) fun P x y = { x = x+y; ( x := !x + !y; y = x-y; y := !x - !y; x = x-y; x := !x - !y } ); How does P behave? How does P behave in a context where x=y ? j P <x = y> We write: f y x g = ñ j P <x = y> f x ñ j P y g <x = y> =
why explicit fusions? • they occur in real world • help implementation • momentum of related work • simplify syntax • 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 hardware cout cin add1 add0 ( <cout> j A 0 ) @ ( <cin> j A 1 ) ñ <cout = cin> j A 0 j A 1 e.g. SHRM [G00]
fusions in internet u v u v u v Fusion allows for asynchronous migration of code: migration can happen gradually, and is non-blocking. eg. ambients [FLS00], pi-calculus machine [in progress] “Explicitly record and delay the effect of the fusion” cf. Explicit Substitutions [ACCL 91]
pi-calculus • communication between output & input u:<y>P j u: ( x ) Q & P j Q f y x g = send y rcv x Q P over u over u Q f y x g = P • dynamic creation of names/channels ( ÷y ) P j Q ñ ( ÷y )( P j Q ) • mobile scope of names/channels
related work 1 pi. [MPW89] u:<y>P output u: ( x ) Q input ( ÷z ) R name-hiding Q & P j Q f y u:<y>P j u: ( x ) x g = explicit fusions. [GW00] pi-I. [Sang96] fusion calculus. [VP98] ( ÷z ) u: ( y ) P; u: ( x ) Q; R chi calculus. [FU97] ( P f z y g j Q f z ( ÷z ) u:<y>P; u:<x>Q; R ( y ) P j u: ( x ) Q & ( ÷z ) x g ) u: = = z fresh u:<y>P j u:<x>Q & ???
related work 2 Categorical Framework Graphs Fusions Explicit Symmetric ACs [GW99] Expl. Subs Fusion Systems [G00] pi-F [GW00] Equators [H95] Permutations [H] Process Graphs [Y94] Term graph rewriting [GM]
pi-F calculus • grammar • reaction relation • structural congruence (e.g. alpha conversion) labels, bisimulation u u ü • use CCS labels ! ! ! • “open” bisimulation • result: is a congruence embedding pi, fusion • how to encode bound inp. • result: reaction preserved. Full abstraction for fusion but not pi
pi-F calculus P ::= nil empty process x:P input x:P output P j P parallel composition ( ÷x ) P name-hiding <x> datum <x = y> explicit fusion datums explicit fusion • are like concretions • denotes an equivalence relation • not commutative • finite basis • polyadic, through parallel composition • has substitutive effect <x> j <y> j P á á á <xy>P
pi-F reaction u:P j u:Q & P @ Q effect of @ is to fuse datums interface ( <y> j ) j u: ( ÷x )( <x> j ) & ( <y> j ) ( ÷x )( <x> j ) u: P Q P @ Q à á ñ ( ÷x ) <x = y> j P j Q ñ P f y x g j Q f y x g = = encode bound input u: ( x ) Q encode lazy input ( ÷x )( u:<x> j Q )
struct.cong. rules for fusions ( ÷x )( x: nil ) create fresh bound name y as alias for x ñ ( ÷x ) ( ÷y ) <x = y> j x: nil ) ( substitute y for x ñ ( ÷x )( ÷y )( <x = y> j : nil ) y remove the now-unused bound name x ñ ( ÷y )( y: nil ) <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 !
pi-F labels, bisimulation u ü u ! ! ! u:P P u:P j u:Q P @ Q u:P P closed w.r.t. contexts and ñ Bisimulation is standard, augmented for fusion contexts: a relation S is an open bisimulation iff whenever PSQ then ï P; Q have same (same datums, fusions, restrictions) interface ë 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 results 1 pi & P j Q f y u:<y>P j u: ( x ) Q x g = piF u:P j u:Q & P @ Q fusion ( ÷x )( u:<x>P j u:<y>Q j R ) & P f y x g j Q f y x g j R f y x g ã = = =
embedding results 1b (1) Structural congruence for pi and fusion embeddings P ã ñ Q ã P ñ Q iff (2) Reaction relation for pi embedding iff P ã & Q ã P & Q (3) Reaction relation for fusion embedding. Need constraint * implies P ã & Q ã P & Q P ã & Q and R ã ñ ( ÷x 9 R; x ~ ) P & R implies ~: ( ÷x ~ ) Q
fusion calculus u:<y>P u:<x>Q ( ÷x ) R standard output u x P ux:P à ! ( x ) x u P ( ÷x ) ux:P standard bound output à ! ! x = y ux:P j uy:Q P j Q interaction results in a fusion à ! ! x = y ux:P j uy:Q j R P j Q j R fusion has potentially global effect à ! P f y x g j Q f y x g j R f y 1 ( ÷x )( ux:P j uy:Q j R ) = = = x g delimit extent of fusion à !
embedding results 2 u: ( <x> j P ã ) u ux P ã <x> j à ! à ! ux:P P u ( x ) x u ( ÷x ) u: ( <x> j P ã ) à ! P ã ( ÷x ) ux:P à ! P ( ÷x )( <x> j ) ü ! x = y P ã j Q ã > j P ã ) j u: ( < > j Q ã ) ux:P j uy:Q u: ( < à ! x y à ! P j Q <x = y> j
embedding results 2b (1) fusion-calculus hyperequivalence coincides with pi-F bisimulation on its embedded image. • proof: take hyperequivalence, close it under all interfaces, and the result is a pi-F bisimulation. And vice versa . (2) pi-calculus open bisimulation is strictly weaker than pi-F bisimulation. • “open” bisimulation [S96] : one that’s closed w.r.t. subsitututions — or fusions • proof [VP98]: in following expression, 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 • use explicit fusions in other areas (“fusion systems”)
Recommend
More recommend
