Interaction Nets. Simon Gay Queens

Transcription

1 Interaction Nets Simon Ga Qeens Diploma in Compter Science 1991

2 Name College Project Title Qeens Simon Ga Interaction Nets Eamination Diploma in Compter Science 1991 Word Cont Approimatel Originator Spervisor Aims of Project Dr. A. Pitts F.J.M. Dave To implement an interactive interpreter for the Interaction Nets langage; also to investigate etensions to the basic langage, nderstand the fondation of the langage in Girard s Linear Logic, and develop eamples of programming in it. Work Completed The original aims of the project have been realised, with the eception of a cople of things (modlarit, investigation of performance) which were in the categor of areas which it might have been interesting to look at. Special Difficlties None.

3 Acknowledgements I wold like to thank Dr. Andrew Pitts for coming p with the original idea for a project based on Yves Lafont s Interaction Nets. It trned ot to be an etremel interesting and enjoable project, allowing both practical and theoretical investigation, and opening p the field of Linear Logic which shold be a good topic for ftre work. I am also gratefl to Francis Dave for being a helpfl and encoraging spervisor. I have benefited from several discssions with him on Linear Logic and tpe theor. He also persaded me to look at polmorphism in Interaction Nets, which became a ver fritfl eercise.

4 Contents 0 Introdction The Interaction Nets Langage Linear Logic and Interaction Nets Additional Langage Featres The Sstem Programming in Interaction Nets Ftre directions Conclsions...45 References...46 Appendi A - Snta of Interaction Nets...47 Appendi B - The User Interface...51 Appendi C - A Sample of the Program...53 Appendi D - The Proposal...65

5 0 Introdction This docment describes a project based on the ideas in [1], in which Lafont proposes the langage of Interaction Nets based on the proof nets of Girard s Linear Logic [2]. The project consisted of implementing an interactive interpreter for the langage, eperimenting with etensions to it, developing eamples of practical programming, and investigating the theoretical framework of Linear Logic and how Interaction Nets fits into it. Firstl, the langage is described, and illstrated with some simple eamples. Then Linear Logic is presented via Seqent Calcls, and the connection with Interaction Nets is eplained. Three classes of etension to the langage are described, dealing with providing an analoge of macros in addition to fnctions, providing fnctions with side-effects, and polmorphic tping. Net, the implementation is discssed, and some eample programs presented. Finall there are some frther thoghts on possible ftre directions. A more complete description of the facilities provided b the sstem, formal snta definitions, an etract from the actal program, and a cop of the original proposal can be fond in the appendices. 1

6 1 The Interaction Nets Langage Interaction Nets is a programming langage based on graph redction. Programming consists of specifing the was in which graphs can be constrcted, and defining rewriting rles. The graphs are known as nets; a net is an ndirected graph with labelled vertices, satisfing certain other conditions. In the pre Interaction Nets langage there are no bilt-in definitions, so for eample nmbers mst be defined b the programmer. One wa to do this is to se a nar representation and consider nets sch as S S 0 where sitable smbol definitions mst be given for S and 0 to allow them to be connected p in this wa. Observe that a net is allowed to have dangling edges which are onl connected at one end. Sch edges can be considered as free variables of the net and are sall labelled. In fact, it is also possible to have edges which are connected at neither end; sch edges are necessar in order to describe some rewriting rles. Each agent (verte) in a net is an instance of some smbol. A smbol definition associates the name of a smbol with a specification of how an agent with that name can be connected to other agents. An agent has a nmber of ports to which edges can be attached. Ports are tped, a tpe specification consisting of a tpe name and a direction. The directions are inpt, represented b -, and otpt, represented b +. Two ports can onl be connected if the have the same tpe and opposite directions. For the arithmetic eample, the declarations tpe Nat; smbol 0 : Nat + S : Nat +, Nat -; introdce a tpe Nat and define smbols 0 and S, giving 0 a single port of tpe Nat + and S two ports of tpes Nat + and Nat -. To do arithmetic with nmbers represented in this wa, interaction rles (graph rewriting rles) sch as Add S S z Add can be sed, where Add is defined b smbol Add : Nat -, Nat -, Nat +; Interaction rles are local; in an interaction, two adjacent agents are replaced b a net. One port of each agent is identified as the principal port, and two agents can onl interact if the are connected b their principal ports. Graphicall, principal ports are z 2

7 distingished b arrows. In a smbol definition, the first port listed is the principal port; the above definitions correctl specif the principal port of each smbol. B convention, the rest of the ports are listed in the order obtained b moving anticlockwise rond the agent. Given a set of smbol definitions, a complete set of interaction rles incldes jst one rle for each pair of smbols whose principal ports can be connected together. For 0, S and Add, the rles are Add 0 Add S S z Add Diagrams like this are the most natral wa to nderstand interaction rles, bt a tetal snta is also sed. In fact, the crrent sstem onl works with tetal descriptions. The form of tpe and smbol definitions is described above, and is easil readable. It is essentiall the same as the notation described b Lafont. The tetal description of a net is obtained b labelling all its edges, inclding both free edges and internal edges, and listing the agents. Each agent appears in the list as its name followed b the labels on the edges emanating from it, in brackets. The edge labels are listed in the order in which the corresponding ports appear in the smbol definition. So the net Add z S z is described b or Add(,z,),S(,) S(,),Add(,z,). An edge which has a free variable at each end is described b the names of the variables separated b a -. The empt net, represented graphicall b is described tetall b the single 3

8 In this notation, an interaction rle consists of a pair of net descriptions separated b an arrow. The net on the left of the arrow mst consist of a pair of agents connected onl b their principal ports. This is different from Lafont's notation for rles, which is described in Appendi A; it is intended to be more readable than his. The rles for addition are defined b rle Add(,,),0() -> - Add(,,),S(,z) -> S(,w),Add(z,,w); With the definitions given so far, the Interaction Nets sstem can be sed to do simple calclations. For eample, to calclate 2+2, the command net Add(,v,),S(,a),S(a,b),0(b),S(v,c),S(c,d),0(d); loads the given net into the sstem, and the command redce applies interaction rles ntil there are no more active links (principal ports connected together) and then prodces the otpt S(,),S(,z),S(z,),S(,v),0(v) The langage of Interaction Nets is based on Linear Logic; nets generalise the proof nets of Linear Logic. The main implication of this connection is that there are linearit constraints on nets and interaction rles. In a net, all free variables mst be distinct, that is, all free edges mst have distinct labels. In a rle, the two sides mst have precisel the same free variables. To see the impact that linearit has in practice, consider defining mltiplication for nar arithmetic. Similarl to addition, the necessar smbol definition is smbol Mlt : Nat -, Nat -, Nat - ; and rles are needed to captre the sal recrsive eqations 0. = 0 (+1). =. +. The obvios rle for the first eqation is 0 Mlt 0 bt this is wrong becase the left side has more free variables than the right side. The problem is that the mltiplication fnction ses its second argment non-linearl; if the first argment is zero, the second argment is discarded. To epress the eqations in the form of linear interaction rles, this discarding of the second argment mst be made eplicit b means of an agent Erase which is defined b smbol Erase : Nat - ; and interacts according to the rles Erase 0 4

9 Erase S Erase The correct rle for the first mltiplication eqation can now be given: Mlt 0 and this can be seen to be linear. 0 Erase The second eqation for mltiplication is non-linear in a different wa: part of one of the argments is dplicated. The obvios interaction rle is Mlt Add S z Mlt which again violates linearit. The soltion this time is to make the dplication eplicit b means of the definition and rles smbol Dpl : Nat -, Nat +, Nat + ; z z Dpl

10 Dpl S S S Dpl z z which allow the correct form of the second rle for Mlt to be given: Mlt Add S z Mlt Dpl Linearit is reall abot control of resorces. Eplicit dplication and deletion mean that an implementation of Interaction Nets needs no garbage collector, since no sharing of sbstrctres is allowed. Interaction rles mst also be well-tped in that as well as the two nets in a rle being well-tped, a free variable mst be attached to ports of the same tpe and direction on both sides of the rle. If the right hand side of a rle contains an isolated edge, the variables on thet edge mst be attached in the left hand side of the rle to ports of the same tpe and opposite directions. It is clear that with these constraints on interaction rles, well-tped nets remain well-tped after an redctions. It is possible to define rles which lead to non-terminating comptations, sch as Lafont's trnstile eample: z Stile Stile Trn Trn Trn Stile Trn Trn Stile Trn... bt frther constraints on nets can ensre that when a seqence of redctions terminates, the reslt can be interpreted as a meaningfl answer rather than a deadlock sitation. When redction stops, the net reached has no active links. Consider starting from some agent and following principal ports arond the net. Eventall, either a free variable is reached, or the path loops. If it is alwas the first case which arises, then the net represents an 'answer' and the free variables are the 'handles' which were attached 6

11 to the original problem. The net is read to interact with its environment - if additional agents are attached to the free variables, redction might be able to contine. Bt if the net contains ccles, the sitation is a deadlock, and it is these cases which shold be eliminated. One possibilit wold be to forbid the constrction of an net containing ccles, bt this is nnecessaril restrictive as it makes it impossible to define rles which se dplication, sch as the second rle for nar mltiplication. However, it is possible to distingish betweem innocos and pathological ccles - the programmer knows that a ccle containing a Dpl agent will be broken after a nmber of applications of the rles for Dpl. The soltion is to divide the ports of each agent into partitions which are sed in the following wa. If a net is bilt p from the empt net b sccessivel adding agents, which ma or ma not be connected to eisting agents, then at an time the net consists of a nmber of connected components. Connecting two or more ports of a new agent to a single component forms a ccle in the net. The rle is that this can onl be done if all the ports being connected to the same component are in the same partition. This garantees that nets containing bad ccles cannot be constrcted; and, since the same constraint applies to the net on the right hand side of an interaction rle, that no bad ccles can be introdced b redctions. The defalt is for partitions to be discrete; non-discrete partitions are specified in a smbol definition b enclosing the relevant ports in crl brackets. So the correct definition for Dpl is smbol Dpl : Nat -, {Nat +, Nat +} ; This means that a partition mst consist of a grop of adjacent ports, so the order of the ports mst be chosen in sch a wa that this is tre. Also, when describing a net containing ccles to the Interaction Nets sstem, the agent which makes a ccle legal (the agent with a non-discrete partition) mst be the last agent in the ccle to be listed, otherwise the sstem cannot check the partitioning. Lafont specifies the optimisation condition that the right-hand side of an interaction rle shold not contain an active links; if it did, the cold be redced at definitiontime to save work when redcing nets later. This condition is not enforced in the present sstem, becase if the natral form of a rle contains active links, leaving them in makes the program clearer. Also, redcing sch active links at definition-time cold lead to non-termination in the parser. Becase the are sed in a later eample, it is worth mentioning here that lists can be represented in Interaction Nets b means of the agents Nat - List + Cons List - List + (for lists of natral nmbers); it is straightforward to write rles for list operations sch as appending, as for eample in the following sample rn. $ inets -pre Interaction Nets # tpe Nat List; # smbol 0:Nat + S : Nat +, Nat - Nil : List + Cons : List +, Nat -, List - Append : List -, List -, List + ; Nil 7

12 # rle Append(,,),Nil() -> - Append(,,),Cons(,v,w) -> Cons(,v,),Append(w,,); # net Append(a,b,),Cons(a,c,d),0(c),Nil(d),Cons(b,e,f),S(e,g),0(g),Nil(f); # redce Cons(,1,),0(1),Cons(,z,),S(z,v),0(v),Nil() This completes the description of the basic langage. Some less trivial eamples, illstrating varios programming techniqes, are discssed in section 5. Bt now, the theoretical fondations of Interaction Nets will be described. 8

13 2 Linear Logic and Interaction Nets In this section Linear Logic is presented, and the connection with Interaction Nets eplained. The eposition of Seqent Calcls, Linear Seqent Calcls and proof nets follows bt epands that in [2]. The eplicit description of how Interaction Nets fits in is new, althogh from hints in varios papers it seems certain that Lafont has developed it previosl. 2.1 Seqent calcls Logical aioms and rles of inference can be presented b in Seqent Calcls, where a seqent A 1,..,A n B 1,..,B n with the A i and B i logical formlae means that B 1 B 2.. B n is the conseqence of A 1 A 2.. A n (where and in this contet are meta-connectives, not part of logic); conseqence, that is, in the sense of sntactic entailment (hence the se of the single trnstile ); there is no notion of trth. A sstem in which the right-hand side of a seqent can contain several formlae is a classical sstem, whereas restricting seqents to be of the form A 1,..,A n B ields an intitionistic sstem. This is the distinction between the philosoph that it is meaningfl to prove A B withot specifing which has been proved, and the intitionist philosoph which onl admits constrctive proofs. In the rles below Γ,,.. stand for seqences of formlae, and are sed to represent the contet in which a rle is being sed. The interpretation of a rle of Seqent Calcls is that the seqent below the horizontal line can be dedced from those above. Ths Seqent Calcls rles are statements abot how valid proofs ma be constrcted, for eample If from the assmptions Γ, I can prove A, and from the assmptions, I can prove B, then from the assmptions Γ,, I can prove A B b anding together the proofs of A and B. When the rle for described above is pt into Seqent Calcls, it takes the form and there is also a slightl different rle Γ A, Γ ' B, ' Γ,Γ' A B,, ' Γ A, Γ B, Γ A B, There are also rles for introdcing on the left-hand side of seqents: Γ,A Γ,A Β Γ,B Γ,A Β Γ,A,B Γ,A Β which formalise the idea that if A B is known then both A and B are known individall. The rles for are similar: Γ,A Γ ',B ' Γ,Γ',A B, ' Γ,A Γ,B Γ,A B Γ A, Γ A B, Γ B, Γ A B, Γ A,B, Γ A B, 9

14 in fact, being dal to, the rles are the same as those for bt with left and right interchanged. There is some redndanc in this formlation of the logical rles, which will be discssed later. There is also the identit aiom A A Id and the ct rle Γ A, Γ',A ' Γ,Γ ', ' In addition to these logical rles, the se of certain strctral rles is made eplicit. These rles control how hpotheses are sed in a proof. The echange rles epress the fact that formlae ma be written in an order: Ct Γ,A,B,Γ' Γ,B,A,Γ' LX Γ,A,B, ' Γ,B,A, ' RX The weakening rle on the left allows additional hpotheses to be introdced, which ma not necessaril be sed in the proof (if A is not listed in Γ): Γ Γ,A LW and on the right, in the classical case, allows dedctions in the stle of If I can prove that 2+2=4, then I can prove that either 2+2=4 or the moon is made of green cheese : Γ Γ A, RW The contraction rle on the left states that a hpothesis need onl be introdced into a proof once, and can then be sed an nmber of times: Γ,A,A Γ,A LC and on the right, that proving A A is no better than proving A: Γ A,A, Γ A, We will not discss qantifiers here, bt it is reasonable to ask how negation and implication fit into this scheme. In particlar, one might epect to introdce together with rles RC Γ,A B, Γ A B, R Γ A, Γ',B ' Γ,Γ',A Β, ' L 10

15 Γ A, Γ ' A B, ' Γ,Γ' B,, ' -Elim First of all, observe that the rles for operating on the right- and left-hand sides of seqents are essentiall the same, with an echange of and. This repetition can be avoided b introdcing negation, so that each atomic proposition comes in the two forms A and A, and sing asmmetrical seqents, replacing A 1,..,A n B 1,..,B n b A 1,..A n,b 1,..,B n. This still fits in with intition: I can alwas prove A 1 A 2.. A n B 1.. B n is eqivalent to If I can prove A 1 A 2.. A n then I can prove B 1 B 2.. B n. Negation is etended to compond formlae b de Morgan s laws: (A B) = A B, (A B) = A B. And b definition, A = A. Ptting the rles of Seqent Calcls into asmmetrical form, the identit aiom becomes the ct rle A, A Id A,Γ A, Γ, (note that what were the contets on opposite sides of a trnstile can now be combined into a single contet on the right); the strctral rles and the logical rles Ct Γ,A,B, Γ Γ,B,A, X A,Γ W A,A,Γ A,Γ C A,Γ A B,Γ 1 B,Γ A B,Γ 2 A,B,Γ A B,Γ 3 A,Γ B, A B,Γ, 1 A,Γ B,Γ A B,Γ The nmber of logical rles can be redced frther. The rle 1 can be derived from 2 b the proof A,Γ A,Γ, * B, B,Γ, A B,Γ, in which the steps marked * consist of several applications of weakening and echange. Conversel, the proof A,Γ B,Γ 2 A B,Γ,Γ A B,Γ * where the step * consists of several applications of contraction and echange, derives 2 from 1. For the rles, the proofs *

16 A,Γ A,B,Γ * A B,Γ 3 B,Γ A,B,Γ * A B,Γ 3 derive the rles 1 and 2 from 3; * is weakening, with an echange in the first proof. Finall the proof A,B,Γ A B,B,Γ 1 B,A B,Γ A B,A B,Γ A B,Γ recovers 3 from 1 and 2. Ths it is sfficient to have jst two logical rles, 3 and either 1 or 2. Going back to the qestion of how to inclde implication, A B can be introdced as a shorthand for A B. In the asmmetrical form, the rle R is A,B,Γ A B,Γ which is jst 3, and similarl L is an instance of 1. The elimination rle becomes X C A,Γ A B, B,Γ, which is obtained from the eisting rles b the proof 2 B,B Id A,Γ A B,B,Γ B,Γ, 1 A B, This recovering of an elimination rle b sing the ct rle is a general featre; the ct rle is an alternative to specifing elimination rles for each connective. The Ct Elimination Theorem, de to Gentzen, states that occrrences of the ct rle can be eliminated from an Seqent Calcls proof which has no hpotheses (that is, from an proof of a tatolog). A proof can be fond in [5]. It will be seen later that ct elimination has an interesting comptational interpretation. 2.2 Linear Seqent Calcls Linear Logic will now be introdced, via Linear Seqent Calcls. Linear Logic was discovered b Girard, who noticed that in a certain model (coherence semantics) of ordinar logic, implication can be broken down into simpler operations. This view will not be discssed here; more details can be fond in [2] and [3]. We jst note that Linear Logic is lower-level than traditional logic in that it allows finer control of resorces. The appropriate step leading from Seqent Calcls to Linear Seqent Calcls is to discard the strctral rles of weakening and contraction. The reslt is a sstem in which a proof mst se each of its hpotheses eactl once; ths there is a sort of conservation of propositions going on. The lack of weakening and contraction means that the alternative formlations of the logical rles for and are no longer eqivalent. To reflect the fact that there are now two essentiall different was of sing Ct 12

17 each connective, two conjnctions and two disjnctions are introdced. The tensor prodct (cmlative conjnction) (times) combines contets: A,Γ B, A B,Γ, while the direct prodct (alternative conjnction) & (with) works within a single contet: The dal connectives A,B,Γ A & B,Γ & & A,Γ B,Γ A&B,Γ (par) for and (pls) for & have rles & A,Γ A B,Γ 1 B,Γ A B,Γ 2 and are related to the conjnctions b de Morgan s laws: (A B) = A (A & & B (A & B) = A B B) = A B (A B) = A & B where is linear negation. As before, the introdction of negation and the se of asmmetrical seqents are prel for convenience. Incidentall, another wa to look at the splitting of each intitionistic connective into mltiplicative and additive versions, pointed ot b Dave (private commnication) is that if both introdction and elimination rles are given the mltiplicatives are introdced like intitionistic connectives and the additives are eliminated like them. Units can also be introdced: 1 for, for, T for & and 0 for. The form two pairs of mtall linearl negated formlae, with 1 = = 1 T = 0 0 = T and rles & Γ,Γ 1 1 (no rle for 0) T,Γ T Discarding the contraction and weakening rles represents a significant loss of power in the logic. To recover it, contraction and weakening are broght back in a controlled form, via the introdction of the modalit! (of corse) and its dal? (wh not): (!A) =?A (?A) =!A with the strctral rles appearing in the form of logical rles for the modalities: Γ?A,Γ W??A,?A,Γ?A,Γ C? A,Γ?A,Γ D? A,?Γ!A,?Γ! where the W, C and D stand for contraction, weakening and dereliction. 2.3 Proof Nets A proof written in Seqent Calcls contains a lot of redndanc, as contets are rewritten withot change each time a logical rle is sed. The interesting featres of a proof can displaed in the form of a proof net. Proof nets appl onl to the so-called mltiplicative fragment of Linear Logic, containing, 1, and. These are the connectives for which the seqent rles have the propert that the contets in the & 13

18 conclsion are the disjoint nions of those in the premise. The other connectives are the additives. The mltiplicative rles add contets together, while the additive rles do not! In a proof net, negated pairs of propositions are linked together when introdced, ses of logical rles appear as before bt withot the contets (the contet is the rest of the proof net), and the ct rle appears as a line with nothing below it. Also, there is no need to eplicitl indicate ses of the strctral rle. For eample, the proof A,A B,B becomes A B,A,B C,C (A B) C,A,B,C A,B,(A B) C,C X A & B,(A B) C,C & A B A B C (A B) C C A A & B B Formall, a proof net is a graph constrcted from the components link: ct: A A A A and logical rles: A B A B A B A B 1 & according to the conditions that each formla mst be the conclsion of eactl one rle and a premise of at most one rle (formlae which are not premises are conclsions of the proof net), and the rles of Linear Seqent Calcls: If A and A are conclsions of the proof nets ν and ν', then is a proof net. If A and B are conclsions of the proof nets ν and ν', then is a proof net. ν A ν ν' A ν' A B A B 14

19 If A and B are conclsions of the same proof net ν, then ν is a proof net. If ν is a proof net, then is a proof net. And finall, 1 is a proof net. A A & ν B B Ct elimination in a proof net consists of rewrites: A A A A A B A B A B A B A A B B & For eample, the proof net 1 (nothing) A B A B C (A B) C redces in three steps to C A A & B B A B A B B A A A B A B C (A B) C It can alread be seen that there is a similarit between proof nets and Interaction Nets. In the net section, the connection is described in detail. 2.4 From Linear Logic to Interaction Nets A correspondence between proofs in a constrctive logic and programs in a tped programming langage can be set p via the Crr-Howard Isomorphism. Logical propositions are interpreted as tpes, and a proof of a proposition corresponds to a C B 15

20 program compting a vale of the corresponding tpe. Ct elimination, which redces a proof to a simpler proof (one withot cts) corresponds to evalating the program to eliminate fnction calls. As ct elimination proceeds, etra information is accmlated on the comptational side of the correspondence, leading to the vale of the final term (rather than its tpe) being interpreted as the reslt of the program. In a traditional fnctional programming langage based on lambda calcls, the correspondence with Intitionistic Logic can be seen; ct elimination corresponds to beta-conversion. In this wa, the relationship between the mltiplicative fragment of Linear Logic and Interaction Nets can be obtained. Tpes of ports (of agents) correspond to propositions, and smbol definitions correspond to logical rles. An agent in a net corresponds to the se of some logical rle in a proof; a net is a proof of the propositions corresponding to the tpes of its free variables. In fact, the net is a graphical representation of the corresponding proof, in the wa that proof nets are. Interaction between agents corresponds to ct elimination; a complete set of interaction rles is a collection of convresions making a proof of the ct elimination theorem for the logic described b the tpe and smbol definitions possible. Of corse, this proof ma not work; the non-terminating trnstile eample is a logic for which the ct elimination theorem fails. Partitioning of the ports of an agent reflects the wa in which logical rles can combine different contets (as for ) or work within a single contet (as for ). In the rles for constrcting proof nets, mst connect twice to the same proof net, whereas a nondiscrete partition of an agent s ports merel allows the possibilit. This is related to the distinction drawn b Lafont [1] between simple and semi-simple nets. A simple net is constrcted b sing the rles LINK (an edge), CUT (a single connection between two nets) and GRAFT (connecting a new agent to nets, according to its partition). The partitioning rle in this case demands that all ports in a partition mst be connected to the same net (which will be connected, viewed as a graph); in addition, an agent sch as Erase can onl be introdced withot a connection if its non-principal ports are all in a partition together (an empt partition, of corse). This means that when Erase interacts with 0 (sa), what is left is not an empt net bt a lone empt partition, a distinction which is not made in the present sstem. Bt some agents of the same shape, sch as 0, do not have an empt partition. This difference is clearl similar to the difference between the Seqent Calcls rles for 1 and ; the rle for involves a contet (which ma be empt) while that for 1 does not. A semi-simple net can be constrcted sing the above rles, together with the etra rles EMPTY (an empt net) and MIX (jtaposing two nets withot a connection). The present sstem allows semisimple nets. It is interesting to observe that the MIX rle for constrcting nets corresponds to a strctral rle & Γ Γ, which is not a rle of Linear Seqent Calcls. The qestion of whether to inclde this rle is discssed in [3], and decided in the negative. More generall, Interaction Nets can be seen as corresponding to the proof nets of mltiplicative logics (in which logical rles combine contets), not jst Linear Logic. While interaction rles are linear in terms of occrrences of free variables, when the tpes are considered an agent sch as Dpl seems to correspond to contraction. It is not clear eactl what is going on here; mabe Dpl implicitl applies modalities to its argments. The Interaction Nets langage as described p to now allows onl atomic tpes, and a program in it describes a logic with no connectives. Bt the langage has been etended to allow the definition of polmorphic tpe constrctors, corresponding to logical connectives. This etension is described, with others, in the net section. & 16

21 3 Additional Langage Featres 3.1 Psedo-agents Psedo-agents are the Interaction Nets eqivalent of macros in traditional programming langages. A psedo-agent has a smbol definition as for an agent, and an epansion rle which is like an interaction rle bt with onl the psedo-agent on the left hand side. The epansion rle specifies a net b which the psedo-agent is replaced when it interacts with another agent. An eample in which psedo-agents are sefl is defining the fnction Reverse for lists. If lists are introdced via tpe List; smbol Nil : List + Cons : List +, Int -, List - ; then the sal efficient reversing algorithm can be implemented b smbol Rev : List -, List -, List + ; rle Rev(,, ), Nil() -> - Rev(,, ), Cons(, v, w) -> Rev(w, s, ), Cons(s, v, ); bt then when sing Rev, the ailiar inpt mst be given Nil to start with. The etra definitions smbol Reverse : List -, List +; rle Reverse(, ) -> Rev(,, ),Nil(); introdce a psedo-agent Reverse; when Reverse is abot to interact with Cons or Nil, the epansion rle is applied to replace the Reverse with a Rev and the appropriate Nil. Psedo-agents do not add an epressive power to the langage. If the epansion rle for a psedo-agent does not contain the psedo-agent itself on the right-hand side, then the psedo-agent can be eliminated from a program b epanding it in all rles and nets. If a psedo-agent does appear in its own epansion, eliminating it involves replacing it b an agent with a dmm principal port. For eample, a psedo-agent defined b smbol Foo : Int -, Int +; rle Foo(, ) ->... Foo(, v)... ; can be replaced b tpe Signal; smbol Foo : Signal -, Int -, Signal -, Int + Go : Signal + ; rle Foo(t,, z, ), Go(t) ->... Foo(z,, s, v), Go(s) ; with an occrrence of Foo(, ) in a top-level net being replaced b Foo(,, v, ), Go(), Go(v). Despite this, psedo-agents are valable as a means of hiding ailiar inpts, as in the Reverse eample and other recrsive algorithms, and for avoiding the se of Go signals which wold tend to obscre certain algorithms otherwise. 3.2 Bilt-in agents and interaction rles The basic langage of Interaction Nets has been etended b the addition of bilt-in definitions to provide inpt/otpt, character handling, and integer arithmetic. The Interaction Nets sstem incldes these etensions b defalt, bt the can be trned off in order to se pre Interaction Nets. This section describes the behavior of the new bilt-in agents and interaction rles. The bilt-in definitions are processed as an other 17

22 definitions at sstem start-p time, bt their internal representations are modified to make them behave in the desired wa. Introdcing bilt-in integers makes it mch more difficlt to check that a program has jst one rle for each possible pair of interacting agents; checking sfficienc of rles has not been etended to cover the bilt-in agents, and in the crrent sstem the checking which was previosl implemented has been disabled Characters The following definitions are made: tpe Char ; smbol AChar : Char + EraseChar : Char - DplChar : Char -, {Char +, Char +} ; rle EraseChar(),AChar() DplChar(,,),AChar() -> AChar(),AChar() ; An AChar agent is a prototpe character. In fact the sstem behaves as if there is an agent for each ASCII character; the name of sch an agent is a character in single qotes. So the effect is as if there were definitions smbol A : Char + q : Char +... The interaction rles involving AChar agents work for all character agents in the wa specified b the above definitions, with the additional propert that DplChar correctl dplicates the particlar character it is given, ie the information as to which character is present is carried across the redction Arithmetic The following definitions are made (the tpe Int is sed to distingish the bilt-in integers from the tpe Nat of natral nmbers defined b sccessors): tpe Int Bool ; smbol AnInt : Int + EraseInt : Int - DplInt : Int -, {Int +, Int +} ABool : Bool + EraseBool : Bool - DplBool : Bool -, {Bool +, Bool +} Add : Int -, Int -, Int + AddN : Int -, Int + Negate : Int -, Int + Eqal : Int -, Int -, Bool + EqalsN : Int -, Bool + LessThan : Int -, Int -, Bool + MoreThanN : Int -, Bool + ; As for characters, AnInt and ABool are prototpes; the sstem behaves as if there is an agent for each integer, with names...,~2, ~1, 0, 1, 2,..., and agents called TRUE and FALSE for the booleans. The interaction rles are again prototpes. There are the obvios rles for erasing and dplication. The rles for addition are rle Add(,v,),AnInt() -> AddN(v,) AddN(,),AnInt() -> AnInt() ; 18

23 where AddN is a prototpe for agents called Add1, Add2,... which behave in the epected wa : Add3(,),5() redces to 8(). The rle for Add is a prototpe for infinitel man (actall onl finitel man de to the modlar arithmetic on the nderling machine) rles of the form Add(,v,),1() -> Add1(v,) Add(,v,),~1() -> Add~1(v,)... The rle for Negate is straightforward: rle Negate(,),AnInt() -> AnInt() and again, this is a prototpe for infinitel man rles. The eqalit and comparison tests are handled similarl to addition via the rles rle Eqal(,v,),AnInt() -> EqalsN(v,) EqalsN(,),AnInt() -> ABool() LessThan(,v,),AnInt() -> MoreThanN(v,) MoreThanN(,),AnInt() -> ABool(); as demonstrated b the dialoge # net Eqal(,v,),3(),4(v); # redce1 Eqals3(1,),4(1) # redce1 FALSE() # net LessThan(,v,),~5(),7(v); # redce1 MoreThan~5(1,),7(1) # redce1 TRUE() Using these smbols and rles, it is possible to define the other arithmetic operations. However, althogh it is possible to write smbol Foo : Bool -, Int -, Int + ; rle Foo(,v,),TRUE() -> -v Foo(,v,),FALSE() -> Negate(v,) ; there is no wa for a ser-defined rle to involve, sa, an AnInt agent and specif that the particlar integer reqired depends on other AnInt agents. So althogh the rle for EraseInt does not have to be bilt-in, the rle for DplInt does Inpt and Otpt The definitions for inpt and otpt are tpe In Ot ; smbol InStream : In + EraseInStream : In - OtStream : Ot - EraseOtStream : Ot + ReadChar : In -, In +, Char + ReadInt : In -, In +, Int + PrintChar : Char -, Ot -, Ot + 19

24 PrintAChar : Ot +, Ot - PrintInt : Int -, Ot -, Ot + PrintAnInt : Ot +, Ot - ; Consider the rles for reading and printing characters; those for integers are similar. The wa ReadChar works is b interacting with an inpt stream to prodce a character and the rest of the inpt stream. The prototpe rle is rle ReadChar(,,),InStream() -> AChar(),InStream(). In the present sstem, all InStreams read from standard inpt, bt in a more general sstem the InStream on the right of the above rle wold be connected to the same file as the one on the left. The AChar on the right of the rle becomes, when this rle is sed in a redction, the net character on the inpt. The reason for making ReadChar otpt the rest of the inpt stream is to ensre that characters can be sed in the order in which the are read. Printing characters is similar bt reqires an ailiar agent: rle PrintChar(,,),AChar() -> PrintAChar(,) PrintAChar(,),OtStream() -> OtStream() In the first rle, the PrintAChar becomes Print A, Print B etc, depending on the AChar on the left. When the second rle is sed, the character in the PrintAChar is sent to the otpt stream, and as for ReadChar, the otpt stream is also retrned. This ensres that characters can be written ot in a known order Drawbacks This approach to providing bilt-in agents is not necessaril the best one. The main problem is that when objects are not bilt b recrsive se of constrctors, an agent representing a fnction can no longer destrctre its argment b pattern-matching. For integers, this means that eqalit testing and hence booleans mst also be bilt-in, althogh the booleans, being a finite and small tpe, cold perfectl well be defined b the ser. Also, the introdction of psedo-agents is necessar. Consider defining the factorial fnction for the bilt-in integers. There will be an agent Fact with Int inpt and otpt, which mst test its argment for eqalit with zero. Ths when Fact is sed, it mst actall be an Eqals0 agent which interacts with the inpt, and so Fact has to be a psedo-agent. Possibl the ideal soltion to the problem of providing bilt-in integers wold allow the sal S and 0 definitions to be sed, with the sstem somehow recognising that a seqence of S agents ending in a 0 agent represents an integer and implementing integer fnctions directl. So a few standard integer fnctions cold be implemented efficientl, bt it wold also be possible to define (for eample) Fact in the sal nar wa (bt it wold se bilt-in mltiplication). Integers cold also be printed and read as digits. No work has been done towards implementing sch an improved scheme. 3.3 Polmorphic tping Interaction Nets can benefit as mch as an langage from the introdction of a polmorphic tpe sstem. It was not immediatel obvios what form polmorphic tping shold take in Interaction Nets, bt it was decided that the natral approach wold be to provide facilities whereb the correspondence with Linear Logic cold be etended from atomic propositions to logical connectives. The reslt is that tpe constrctors can be defined, corresponding to logical connectives; the can be of arit one or two. Instead of annotating tpes with + or -, ^ is sed to represent the linear negation. Negating a tpe constrctor gives a dal constrctor, corresponding to the dal connective. Tpe variables `a, `b,... can be sed in tpe epressions; the can also be negated b ^. Two ports can be connected if the tpe of one is the negation (as a 20

25 logical formla) of the tpe of the other. Bilding a net involves nifing the tpes of ports being connected, instantiating tpe variables if necessar. For eample, the definitions for polmorphic lists are tpe List : 1; which declares List as a (postfi) tpe constrctor of arit one, and smbol Nil : `a List Cons : `a List, `a^, `a^ List^ ; where the tpe `a^ List^ represents an inpt of tpe `a List, being its dal. Defining tpe smbol means that a net sch as Int; 0 : Int S : Int, Int^ ; Cons(,, z),0(),nil(z) can be constrcted; in this net, the free variable has tpe Int List, which the sstem indicates b displaing the net as Cons( : Int List,, z),0(),nil(z) The bilt-in definitions can be made polmorphic: EraseChar, EraseInt and so on can be replaced b a single Erase, defined b smbol Erase : `a ; and similarl for dplication: smbol Dpl : `a^, {`a, `a} ; bt separate rles still have to be defined for interactions with each possible agent. With this tpe sstem, it is possible to epress the mltiplicative fragment of Linear Logic within Interaction Nets via the definitions tpe 1 T : 2; which declare the nit tpe 1 and the (infi, associating to the left) tpe constrctor T (for ) of arit 2, smbol One : 1 Bottom : 1^ Times : `a T `b, `b^, `a^ Par : `a T^ `b, {`b^, `a^ } ; giving agents corresponding to the sal logical rles, and rle One(),Bottom() Times(,, z),par(,, v) -> -, z-v ; which enable the ct elimination theorem to be proved. Tpe variables on free edges represent atomic propositions; the identit aiom is sed implicitl in the form of an edge, one end being immediatel connected to an agent. Cts between atomic propositions do not appear in the interaction net. The eample proof net redction of section 2.3 can be done in Interaction Nets as follows: # net Times(,,p),Times(p,q,r),Par(s,q,r),Times(s,v,); # show_net Times(: `b T `a T `c,: `c^,v1),times(v1,w,1),par(1,w,1),times(1,v: `a^,: `b^ ) 21

26 # redce Times(: `b T `a T `c,: `c^,v1),times(v1,v: `a^,: `b^ ) The tpe variables `a and `b have become reversed with respect to the propositions A and B, as a reslt of which one happens to be named first when the net is printed. It is actall possible to represent proof nets in Interaction Nets in sch a wa that cts between atomic propositions can be seen. A smbol definition smbol Id : `a, `a^ ; is needed, and an interaction rle rle Id(, ), Id(, z) -> -z ; With these definitions, the introdction of A and A is represented b the fragment of net Id(, ), Id(z, ) where is the A end (with tpe `a) and z is the A end.(with tpe `a^) Cts between A and A then have to be eliminated sing the interaction rle for Id. This scheme corresponds to the sal ct elimination process; doing withot the cts between atomic propositions implements the fast ct elimination mechanism described in [2]. Slow ct elimination on the same proof net takes three steps, as mentioned before: # net Times(,b,a),Id(b,c),Id(,c),Times(a,e,d),Id(e,g),Id(d,f),Id(h,f), Id(i,g),Par(j,i,h),Times(j,l,k),Id(l,m),Id(k,n),Id(v,m),Id(,n); # show_net Times(: `a^ T `b^ T `c^,v1,w),id(v1,1),id(: `c,1),times(w,1,z),id(1,1), Id(z,v2),Id(w1,v2),Id(2,1),Par(2,2,w1),Times(2,z1,2),Id(z1,v3),Id(2,w2), Id(v: `b,v3),id(: `a,w2) # redce1 Times(: `a^ T `b^ T `c^,v1,w),id(v1,1),id(: `c,1),times(w,1,z),id(1,1), Id(z,v2),Id(w1,v2),Id(2,1),Id(2,2),Id(w1,z1),Id(v: `b,2),id(: `a,z1) # redce1 Times(: `a^ T `b^ T `c^,v1,w),id(v1,1),id(: `c,1),times(w,1,z),id(1,1), Id(z,v2),Id(w1,1),Id(w1,2),Id(v: `b,2),id(: `a,v2) # redce1 Times(: `a^ T `b^ T `c^,v1,w),id(v1,1),id(: `c,1),times(w,1,z),id(1,1), Id(z,v2),Id(v: `b,1),id(: `a,v2) (this tetal otpt is rather opaqe, and is inclded to demonstrate that proof net redctions have actall been carried ot b the sstem). Polmorphic tping is another good reason for not reqiring interaction rles for all possible interacting pairs of agents. Once Erase is polmorphic, it can potentiall interact with (for eample) the principal inpt of Add; mabe Erase interacting with inpts can be interpreted as an eception which propagates itself pwards, bt what abot Dpl? Most of the time, the programmer probabl does not want to worr abot sch things. Also, checking the completeness of interaction rles in the polmorphic case is more difficlt! 22

27 4 The Sstem The sstem provides an environment for eperimenting with Interaction Nets programming. It allows programs to be written and eected - that is, it accepts tpe, smbol and rle definitions, allows nets to be entered, and will redce a given net to normal form b appling the given interaction rles. The sstem checks tping, linearit and partitioning as it processes definitions. It also allows nets to be redced step b step and eamined at each stage, as an alternative to carring ot the whole seqence of redctions withot stopping. Frther facilities allow programs to be written to and read from files. A complete description of the ser interface appears in an Appendi. As well as implementing the basic Interaction Nets langage, the sstem implements certain additional langage featres as described previosl. The bilt-in definitions are optional, and can be trned on or off when the sstem is started p: entering the sstem with the command inets incldes the bilt-ins, while inets -pre leaves them ot. 4.1 Implementation of the basic sstem The sstem is implemented in Modla-3, rnning in a Uni environment. It was decided to se an imperative langage rather than a fnctional or declarative langage, becase the fndamental operation of carring ot a redction b appling an interaction rle to a net is natrall viewed as pdating a global state, and is most easil programmed in an imperative stle. Modla-3 was felt to be the most sitable of the available imperative langages, as it is higher-level than C and provides sefl constrctions which Modla-2 omits, sch as eception handling. Uni was the onl available environment in which to se Modla-3, and also its wide range of program development tools gave it an advantage over Phoeni. In retrospect, these were the right decisions. The actal program is strctred as a nmber of separate modles, in order to divide it into sections providing different tpes of fnction and also to take advantage of the possibilities for separate compilation. B sing the make sstem of Uni, it is possible to ensre that onl the minimm amont of recompilation is done when a change is made to the program. A recrsive descent parser is sed to process tpe, smbol and rle definitions. This method was chosen becase it is eas to implement and, since it detects snta errors as soon as possible, can be made to give clear error messages. It was also straightforward to etend the parser to handle new snta. Nets are represented b strctres of cells and pointers which reflect the wa in which their agents are connected together. A redction step involves coping the net on the right hand side of a rle and then moving a lot of pointers to bild the cop into the eisting net. Active links are stored on a stack. It was mentioned previosl that redcing a net need not introdce an garbage. However, Modla-3 incldes a garbage collector, so the present implementation does not bother to eplicitl free storage, letting the rntime sstem clean p instead. The top level of the sstem is a ver simple command interpreter. Its onl interesting featre is that it can call itself recrsivel to read definitions and commands from a file. 4.2 Implementation of psedo-agents Epanding a psedo-agent is essentiall the same as appling an interaction rle; the onl difference is that jst one agent is replaced b a section of net, rather than an interacting pair of agents. The code for appling a rle was copied and modified to prodce the code for epanding a psedo-agent. It wold probabl have been possible 23

28 to prodce a single procedre for both fnctions, bt it was felt that this wold make the programming nnecessaril difficlt. 4.3 Implementation of bilt-in definitions The prototpe definitions are stored in the same wa as an other definitions. Bt their representations are modified to case the reqired special behavior. All agents can contain a piece of etra information; for most agents there is none, bt an AnInt agent, for eample, holds the actal integer which it represents. When an agent is read or printed, names mst be allowed which reflect the internal data specific to that agent. To achieve this, a smbol can have a read-name fnction and a print-name fnction. The print-name fnction maps internal data to a tetal name, and if present is sed when printing an agent with that smbol definition. A read-name fnction maps in the opposite direction. When an agent is being read, and a name is encontered which is not the name of an smbol, the read-name fnctions are sed in trn to attempt to interpret the name as a valid one for their smbol. If one of them scceeds, the appropriate agent is prodced, with internal data given b the read-name fnction. Finall, internal data of agents needs to be transferred across an interaction rle. To do this, a rle can have a list of fnctions which the internal data of the interacting agents to the internal data of each agent on its right hand side. These fnctions ma case sideeffects, for eample in the case of the bilt-in agents for inpt and otpt. 4.4 Implementation of polmorphism The parser was modified to allow declaration of tpe constrctors as well as atomic tpes, and reading of tpe strctres. Port tpe specifications in smbol definitions have been replaced b tree strctres, and the ver simple test for matching of ports previosl sed was replaced b a tpe nification algorithm. This works b matching trees, instantiating tpe variables where necessar and keeping track of mltiple instances of tpe variables. Instantiating a tpe variable is done b coping a pointer to the new vale (when making the variable eqal to an eisting tpe) or bilding a new tree (when making the variable dal to an eisting tpe). Free variables of nets are decorated with tpe information, becase when tpe-checking while adding an agent, the tpe of a free variable can no longer be taken from a smbol definition (becase it ma have been instantiated frther b the wa in which the net has been connected p). This also allows the tpes of a net s free variables to shown when the net is displaed. A small point abot snta oght to be mentioned here. To make life easier for the parser, mltiple smbol definitions in one smbol command mst be separated b fll stops, in the polmorphic version of the sstem. This is not entirel satisfactor, bt sntactic details are less important than the langage etensions; and since the snta of port tpes is also different, this slight qirk does not make moving programs between versions of the langage significantl more troblesome. 24

29 5 Programming in Interaction Nets In the eample programs which follow, the port tpes of agents are not alwas specified before the are sed in interaction rles; the can sall be dedced from the rles. The important part of a program is the collection of rles, which are alwas shown. The first three eamples are for the simpl tped version of Interaction Nets; the final one is polmorphic. 5.1 Combinator redction SK-combinators are a well-known alternative to λ-calcls as a notation for fnction application. The are described and motivated in [6] and [7], and have the advantage of doing withot variables. The combinators are defined b K = λ., S = λz. ( z). Since evalation of combinator epressions can convenientl be carried ot b means of graph rewriting rles, it is plasible that evalation of combinator epressions in Interaction Nets shold be fairl straightforward. This does indeed trn ot to be the case; the infrastrctre needed to carr ot graph rewrites according to a given set of rles is present in the Interaction Nets interpreter, and it is onl necessar to define appropriate smbols and rles. A combinator epression can be represented natrall as a binar tree, with S s and K s at the leaves; for eample the epression S K K (well known to eqal I, the identit) takes the form: K There are two rewriting rles, one for S and one for K : S K z S z 25

30 K To translate all this into Interaction Nets, we define agents corresponding to S, K and the intermediate nodes: Tree+ Tree+ Tree+ S K Node Tree- Treeand specif how S and K leaves interact with intermediate nodes. Ailiar agents are needed since the original tree rewriting rles are not local (in the sense of Interaction Nets rles), and some erasing and dplication is needed becase of the non-linear natre of S and K : S ses an argment twice, and K discards one. The appropriate interaction rles are as follows (the rles for erasing and dplication are not shown, as the are ninteresting): K Node AK Node Erase AK z Node S AS 26