<?xml version="1.0" standalone="yes"?>
<Paper uid="C94-2143">
  <Title>STRUCTURE SHARING PROBLEM AND ITS SOLUTION IN GRAPH UNIFICATION</Title>
  <Section position="1" start_page="0" end_page="0" type="metho">
    <SectionTitle>
STRUCTURE SHARING PROBLEM AND ITS SOLUTION
IN GRAPH UNIFICATION
Kiyoshi KOGURE
NTT Basic Research Laboratories
</SectionTitle>
    <Paragraph position="0"> kogure~at om. ntis. jp</Paragraph>
  </Section>
  <Section position="2" start_page="0" end_page="0" type="metho">
    <SectionTitle>
ABSTRACT
</SectionTitle>
    <Paragraph position="0"> The revised graph unification algorithms presented here are more efficient because they reduce the amount of copying that was necessary because of the assumption that data-structure sharing in inputs occurs only when feature-structure sharing occurs.</Paragraph>
  </Section>
  <Section position="3" start_page="0" end_page="0" type="metho">
    <SectionTitle>
1 INTRODUCTION
</SectionTitle>
    <Paragraph position="0"> Constraint-based linguistic frameworks use logical systems called feature logics (Kasper &amp; Rounds, 1986; Shieber, 1989; Srnolka, 1988), which describe linguistic objects by using logical formulas called feature descriptions that have as their models feature structures or typed feature structures. Shieber (1989) argued that if the canonical models of finite formulas of a feature logic were themselves finite, we could use them to compute over instead of theorem-proving over the fornmlas themselves. This would be advantageous if we had efficient algorithms for manipulating the canonical models.</Paragraph>
    <Paragraph position="1"> The most important operation on models- feature structures or typed feature structures is combining the information two models contain. This operation is traditionally called unification, although recently it has come to be more suitably called informational union. This unification operation is significant not only theoretically but also practically because the efficiency of systems based on constraint-based formalisms depends on the (typed) feature structure unification and/or feature description unification algorithms they use. 1 This dependency is especially crucial for monostratal formalisms -that is, formalisms which use only (typed) feature structures such as HPSG (Pollard &amp; Sag, 1987) and JPSG (Gunji, 1987)? The efficiency of (typed) feature structure unification has been improved by developing algorithms that take as their inputs two directed graphs representing (typed) feature structures, copy all or part of them, and give a directed graph representing the unification result. These algorithms are thus called graph unification. Previous researeh has identified graph copying as a significant overhead and has attempted to reduce this overhead by lazy copying and structure sharing.</Paragraph>
    <Paragraph position="2"> Unification algorithms developed so far, however, including those allowing structure sharing seem to  sis system based on HPSG (Kogure, 1989) uses 90%-98% of the processing time for feature structure unification.</Paragraph>
    <Paragraph position="4"> contradict structure sharing because they assmne the two input graphs never share their parts with each other. This &amp;quot;structure sharing&amp;quot; assumption prevents the initial data structures fl'om sharing structures for representing linguistic principles and lexical information even though many lexical items share common information and such initial data structure sharing could significantly reduce the amount of data structures required, thus making natural language systems much more efficient. Furthermore, even if the structure sharing assumption holds initially, unification algorithms allowing structure sharing can yield situations that violate the assumption. The ways in which such unification algorithms are used are therefore restricted and this restriction reduces their efficiency.</Paragraph>
    <Paragraph position="5"> This paper proposes a solution to this &amp;quot;structure sharing problem&amp;quot; and provides three algorithms. Section 2 briefly explains typed feature structures, Section 3 defines the structure sharing problem, and Section 4 presents key ideas used in solving this problem and provides three graph unification algorithms that increase the efficiency of feature structure unification in constraint-based natural language processing.</Paragraph>
  </Section>
  <Section position="4" start_page="0" end_page="886" type="metho">
    <SectionTitle>
2 TYPED FEATURE STRUCTURES
</SectionTitle>
    <Paragraph position="0"> The concept of typed feature structures attgments the concept of feature structures. A typed feature structure consists of a set of feature-value pairs in which each value is a typed feature structure. The set of type symbols is partially ordered by subsumption ordering _&lt;7 and constitutes a lattice in which the greatest element T corresponds to 'no information' and the least element J_ corresponds to 'over-defined' or 'inconsistency.' For any two type symbols a, b in this lattice, their least npper bound and greatest lower bound are respectively denoted a VT b and a AT- It).</Paragraph>
    <Paragraph position="1"> Typed feature strnctures are represented in matrix notation as shown in Fig. 1, where syn, agr, sg, and 3rd are type symbols; agree, hum, per, and subj are feature symbols; and X is a tag symbol. A feature-address that is, a finite (possibly empty) string of feature symbols is used to specify a feature value of an embedded structure. In Fig. 1, for example, the structure at the feature-address agree . uum, where '.' is the concatenation operator, is said to have sg as its type symbol. The root feature-address is de- null noted by '(.' To specify token-identity in matrix notation, a tag symbol is used: feature-address values with the same tag symbol arc token-identical, and those featm'e-addresses with the token-identical value are said to corefer. /n Fig. 1, the feature-addresses agree and subj * agree corefer.</Paragraph>
    <Paragraph position="2"> A typed feature, structure is also represented by a rooted, connected, directed graph within which each node corresponds to a typed feature structure and is labeled with a type symbol (and, optionally, a tag symbol) and each arc corresponds to a feature.-value pair and is labeled with a ti'~ature symbol. Fig. 2 illustrates the graph representation of the typed feature structure whose matrix notation is shown in Fig. 1.</Paragraph>
    <Paragraph position="3"> In a graph representation, the values at corefcrent Ihature-addresscs that is, token-identical values are represented by the same node.</Paragraph>
    <Paragraph position="4"> '\['he set of typed featm:e structures is also partially ordered by a subsumption ordering that is an exten-siou of the subsnmptiol, ordering on the set of type symbols. A typed feature structure tl is less than or equal to tu (written as tl &lt;, in) if and only if tt is iuconsistent (that is, if it includes the type symbol \]_) or (i) t~ 's type symbol al is less than or equal to t~'s type symbol a2 (a~ _&lt;7 ap.); (ii) each h'.atur(~ f of 12 exists in ll and has a value 12, f such that its counter= part ttj is less than or equal to t2,j'; m'/\] (iii) each coreference relation holding in 12 also holds in 11.</Paragraph>
    <Paragraph position="5"> '.l'his subsumpl, ion ordering serves its the basis for (Mining two lattice operations: generalization (the least upper bound or join) and unitlcation (the greatest lower bound or meet).</Paragraph>
    <Paragraph position="6"> Typed feature structures have been formalized in several ways, such as by using .I/%types (Mt-Kaci, 198~).</Paragraph>
  </Section>
  <Section position="5" start_page="886" end_page="888" type="metho">
    <SectionTitle>
3 THE STRUCTURE SHARING
</SectionTitle>
    <Paragraph position="0"/>
    <Paragraph position="2"/>
    <Section position="1" start_page="886" end_page="887" type="sub_section">
      <SectionTitle>
3.1 Graph Unification Algorithms
</SectionTitle>
      <Paragraph position="0"> The destructive unitlcation algorithnl presenled by Aitq(aci is the starting point in increasing the efliciency of graph unification. It is a node-merging process that uses the Unio&gt;Find algorithm, which wits originally devek)t)ed for testing tinite automata equivalence (llopcroft &amp; Karp, 1971), in a manner w.'ry similar to that of the unification algorithm for rational terms (llnet, 197(i). (',iveu two root nodes of graphs representing (typed) feature structures, this algorithm simultaneously traverses a pair of input nodes with the same feature-address, putting them  into a new and larger coreference class, and then returns the lnerged graph, Since the destructive unification process modifies its input graphs, they must first be copied if their contents are to bc preserved. Nondeterminism in parsing, for example, requires the preservation of graph structures not only for initial graphs representing lcxical entries and phrase structure rules but also for those representing well-formed intermediate structures. Although the overhead for this copying is significant, it is impossible to represent a resul.taut unitied graph without creating any new strut tures. Unnecessary copying, though, must be identified and minimized. Wroblewski (1987) delined two kinds of unnecessary copying- over-copying (copying structures not needed to represent resultant graphs) and early-copying (copying structures even though unitication fails) -but this account is flawed because the resultant graph is assumed to consist only of newly created structures even if parts of the inputs that are not changed during mtitication could be shared with the resultant graph. A more eNcient unification algorithm would avoid this redundant copying (copying structures that can be shared by the input and resultant graphs) (Kogure, 1990). To distinguish structure sharing at the implementation level fl'om that at the logical lew'l (that is, coreference relations between feature-addresses), the lbrmer is called data-structure sharing and the latter is called feature-structure sharing (Tomabechi, 1992).</Paragraph>
      <Paragraph position="1"> '\['he key approaches to reducing the amount of structures copied are lazy copying and data-structure sharing. For lazy copying, Karttnnen (1986) proposed a reversible unification that saves the original contents of the. inputs into prealloeated areas immediately before destructive modification, copies the resultant graph if necessary, and then restores the original contents by undoing all the changes made during mlitication. Wroblewski (1987), on the other hand, proposed a uondestructiw~ unitication with incremental copying. Given two graphs, Wroblewski's algorithm simultaneously traverses each pair of input nodes with the same feature-address and creates a (:ommon copy of the input nodes. The nondestructive unification  algorithm for typed feature structures uses the data structures shown in Fig. 3. a The algorithm connects an input node and its copy node with a copy link that is, it sets the copy node as the input's copy field value. The link is meaningflfl during only one unification process and thus enables nondestructive modification. 4 Using an idea similar to Karttunen's, Tomabechi (1991) proposed a quasi-destructive unification that uses node structures with fields for keeping update information that survives only during the unification process. 5 Unification algorithms allowing data-structure sharing (DSS unification algorithms) are based on two approaches: the Boyer and Moore approach, which was originally developed for term unification in theorem-proving (Boyer &amp; Moore, 1972) and was adopted by Pereira (1985); and the lazy copying suggested by Karttnnen ~nd Kay (1985). Recent lazy copying unification algorithms are based on Wroblewski's or Tomabeehi's schema: Godden (1990) proposed a unification algorithm that uses active data structures, Kogure (1990) proposed a lazy incremental copy graph (LING) unification that uses dependency-directed eol)yiug, and Emeie (1991) proposed a lazy-incremental copying (LIC) unification that uses chronological dereference. These algorithms are b0,sed on Wroblewski's algorithm, and Tomabechi (1992) has proposed a data-structure-sharing version of his quasi-destructive unification.</Paragraph>
    </Section>
    <Section position="2" start_page="887" end_page="888" type="sub_section">
      <SectionTitle>
3.2 The Structure Sharing Problem
</SectionTitle>
      <Paragraph position="0"> The graph unification algorithms mentioned so far-perhaps all those developed so far--assume that data-structure sharing between two input structures occurs only when feature-structure sharing occurs between feature-addresses they represent. This &amp;quot;structure sharing&amp;quot; assumption prevents data-structure sharing between initial data structures for representing linguistic principles and lexical information even though many lexical items share common information. For example, many lexical items in a traditional syntactic categories such as noun, intransitive verb, transitive verb, and so on share most of their syntactic information and differ in their semantic aspects such as semantic sortal restriction. Such initial data-structure sharing could significantly reduce the amount of data structures required and could therefore reduce pageswapping and garbage-collection and make natural language processing systems much more efficient.</Paragraph>
      <Paragraph position="1"> Furthermore, even if the structure sharing assumption holds initially, applying a DSS unification algorithm in natural language processing such as parsing and generation can give rise to situations that violate the assumption. Consider, for example, JPSGaFor the nondestructive unification algorithm, the node structure takes as its copy field value either NJ L or a node structure only.</Paragraph>
      <Paragraph position="2"> 4In this algorithm each unification process has an integer as its process identifier and each node created in a process has the identifier as its generation field vMue. A copy link is meaningful only if its destination node has the current process identifier. Such a node is called ~current.' ~The technique used to control the lifetime of update data is the same as that of Wroblewski's algorithm.</Paragraph>
      <Paragraph position="3"> based parsing. There are only a few phrase structure rules in this fl'amework and the Complement-Head Construction rule of the form 'M --+ C It' is applied very frequently. For instance, consider constructing a structure of the form \[vP~ NP2 \[vP, NP1 VII. When the rule is applied, the typed feature structure for the rule is unified with the structure resulting from embedding the typed feature structure for NPl at the feature-address for the complement daughter in the rule (e.g., dtrs. cdtr), and the unification result is then unified with the structure resulting from embedding the typed feature structure for V at the feature-address for the head daughter. Because not every substructure of the structure for the rule always changed during such a unification process, there may be some substructures shared by the strneture for the rule and the structure for VP1. Thus, when constructing VP2 there may be unexpected and undesired data-structure sharing between the structures.</Paragraph>
      <Paragraph position="4"> Let me illustrate what happens in such eases by using a simple example. Suppose that we use the non-destructive unification algorithm or one of its data-structure sharing versions, the LING or I,IC algorithm. The nondestructive and LING unification algorithms use the data structures shown in Fig. 3, and the LIC algorithm uses the same data structures except that its ~zode structure has no forward field. Consider unification of the typed feature structures tl and t2 shown in Fig. 4(a). Suppose that t, and t2 are respectively represented by the directed graphs in Fig. 4(b) whose root nodes are labeled by tag symbols X0 and X4. That is, tj's substructure at feature-address f2 and t2'S substructure at \]'1 are represented by the same data structure while feature-structure sharing does not hold between them, and tl's substructure at \]3 and t2's substructure at; f4 are represented by the same data structure while feature-structure sharing does not hold between them. Each of the algorithms simultaneously traverses a pair of input nodes with the same feature-address both of the inputs have Dora the root feature-address to leaf feature-addresses, makes a common copy of them to represent the unification result of that featureaddress, and connects the input and ontput nodes with copy links. For any feature-address that only one of the inputs has, the nondestructive unification algorithm copies the subgraph whose root is the node for that feature-address and adds the copied subgraph to the output structure, whereas the LING and LIC algorithms make the node shared by the input and outpnt structures. In the case shown in Fig. 4(b) the root nodes of the inputs nodes with the tag symbols Xo and X4 are first treated by creating a common copy of them (i.e., the output node with Yo), connecting the input and output nodes with copy links, and setting bo = ao A:r a4 as the copy's lsymbol wdue.</Paragraph>
      <Paragraph position="5"> Then the input nodes' arc structures are treated. Snt&gt; pose that the pair off1 arcs is treated first. After the input nodes at feature-address fl are treated in the same manner as the root nodes, the pair of fie arcs is treated. In this case, tl's node at f2 (labeled X2) already has a copy link because the node is also used as t2's node at \]'1 so that the destination node of the link is used as this featnre-address's output node. Af-</Paragraph>
      <Paragraph position="7"> (c) Wrong graph unili(:ation outl)ut (ta) and the cot-rect unifi(-ation of the inputs (t~ At Zp,,).</Paragraph>
      <Paragraph position="8"> l&amp;quot;ig. 4: An examph; of incorrect graph unitication.</Paragraph>
      <Paragraph position="9">  ter the common label arcs are treated, unique label arcs are treated. The nondestructive, unitication algorithm copies tl's Ca and t~'s f4 arcs and adds them go the output root node, whercas the LING and tIC a.1gorithms make the input and output structures share their destination nodes, t:'inally, the I,ING and MC algorithms obtain gr~l)h t: n represented in matrix notation ill Fig. 4(('i)just over the correct result.</Paragraph>
      <Paragraph position="10"> The nondestructive unification algorithni obtains the same typed feature structure. The reversible and the quasi-destructiw', unification algoril, hms are also ,mable to obtain the correct result for this example becatlS(; these Mgorithms cmmot represent two update nodes by using a single node. Thus, none of tile ctiicient unification algorithms developed re, ce, ntly obtains the correct results R)r such a case. Avoiding such wrong unification results requires undesirable copying. We can, for example, avoid getting the wrong result by interleaving tile application of any non-DSS unilication algorithm between N)plications of a I)SS unitication algorithm, but such bypassing requires two unilication programs and reduces the efficiency gain of I)SS unification. This prechlsion of useful data-structure sharing is referred to here as the 'structur~ sharing&amp;quot; problem.</Paragraph>
      <Paragraph position="11"> It has been shown that all the/)SS mfiticat.ion nlgo rithins lncntioned above are subject to tMs problem even if the structure sharing assumption holds initially. Non-I)SS unification Mgorithms are also sub-ject to the problem because their inputs are created 1)y applying not only the unitication operation but also operations such as embedding and extraction, in most implelnentations of which data-structure shar.</Paragraph>
      <Paragraph position="12"> hag occurs t)etween their input and output structures.</Paragraph>
      <Paragraph position="13"> 1!3ven non-l)SS unification algorithms must there, fore take such inputs into act(mat, and this requires undesirable copying.</Paragraph>
    </Section>
  </Section>
  <Section position="6" start_page="888" end_page="891" type="metho">
    <SectionTitle>
4 A SOLUTION '1'O THE STRUCTURE
SHARING PROBLEM
</SectionTitle>
    <Paragraph position="0"/>
    <Section position="1" start_page="888" end_page="889" type="sub_section">
      <SectionTitle>
4.1 Key Ideas
</SectionTitle>
      <Paragraph position="0"> The example ill Section 3 suggests that the structlu'e sharing l)roblem has two sources, which concern not only the increnmntal Col)ying al)proach but also other al)proaches. The tirst source is the way of rec, ording ul)date inibrmation. In the incremental Col)ying at)proach, this corresponds to the way of copying structures. That is, while calculating t l A t t, 2 the incr(:men tal copying process does not (lisl, inguish between the copies cremated tuq tim sul&gt;strucl;ures of the left input l t and the copies created as tile substructures of the right input t2. As a result, a copy node oft1 's node at f~ature-address p can be used as a copy node of t~'s nod(', at a feature-address, and vice versa. In Fig. 4(10, fbr example, tile copy of t2's node al; f2 is wrongly used as the copy of tl's node at fl. This causes unexpected and wrong data-structure sharing in the r(~sultant graph and this in turn catlses unexpect(~d and wrong feature-structure sharing in the resultant (typed) fc~t, ure s'\[,rllcttlro. Ill other apl)roachcs , such as the quasi-destructiw~ apl/roach , the source of the structure sharing prol)lem is that each node structure has tMds for keeping information on only two typed feature structures one for the original and one R)r tilt: result wheretm fields for keeping information on three typed feature structures are needed one for tl&gt; original and one for each of the two results, One way to solve this problem is therel'ore to nlake each node keep information on thre, c typed fe, ttturc structures: in the increnrental COl)ying apl)roach ca(;h nod(: must have two copy tields, and in the quasido, structive ;t\[)t)roach each llode l)lUSt have two sets of llelds for updates.</Paragraph>
      <Paragraph position="1"> 'Fhe second source of the structure sharing prob lem is the method of data-stru(:ture sharing between input and output structures. Unexpected and wrong data-structure sh~ring may result if a node shared by the leg and right inputs is used as part of the left input, intended to be shared between the left input and output, at the same time it is used as part of the right input, intended to be shared between the right input  and output. In Fig. 4(b), for example, tl's node at feature-address f~ is shared as t3's node at the same feature-address, and the same node as t2's node at f4 is shared as ta's node at the same feature-address.</Paragraph>
      <Paragraph position="2"> This problem can be solved easily by keeping information on data-structure sharing status; that is, by adding to the node structure a new field for this purpose and using it thus: when a unification algorithm makes a node shared (for example, between the left inpnt and output), it records this information on the node; later when tilt algorithm attempts to make the node shared, it does this only if this data-structure sharing is between the left input and output.</Paragraph>
    </Section>
    <Section position="2" start_page="889" end_page="890" type="sub_section">
      <SectionTitle>
4.2 Algorithms
</SectionTitle>
      <Paragraph position="0"> This section first describes a non-DSS unification algorithm that discards the structure sharing assumption and thus permits initial data-structure sharing, and then it describes two DSS unification algorithms.</Paragraph>
      <Paragraph position="1"> Revised Nondestructive Unifi(:ation This Mgorithm uses, instead of the node structure shown in Fig. 3, the node structure in Fig. 5. That is, the algorithm uses two kinds of copy links: Icopy for the left input and rcopy for the right input.</Paragraph>
      <Paragraph position="2"> Tilt revised nondestructive unification procedure for typed feature structures is shown in Figs. 6 and 7.</Paragraph>
      <Paragraph position="3"> Given two root nodes of directed graphs, the top-level procedure Unify assigns a new unification process identifier, generation, and invokes Unify_Aux. This procedure first dereferences both input nodes. This dereference process differs from the original one in that it follows up fortvard and lcopy links for the left input node and forward and rcopy links for the right input node. This revised dereference process eliminates the first source of the structure-sharing problena. Then Unify_A*tx calculates the meet of the type symbol. If the meet is +-, which means inconsistency, it finishes by returning _L Otherwise Unify_Auz obtains tilt output node and sets the meet as its tsymbol value. The output node is created only when neither input nodt is current; otherwise the output node is a current input node. Then Un*fy_Aux treats arcs. This procedure assmnes the existence of two procedures: Share&amp;Arc_Pair,s and Complement_Arcs. The former gives two lists of arcs each of which contains ares whose labels exist in both input nodes with the same are label order; the latter gives one list of arcs whose labels are unique to the first input node. For each arc pair obtained by Shared_A re_Pairs, Unify_A ux applies itself recursively to the value pair. And for each arc obtained by Complement_Ares, it copies its value.</Paragraph>
      <Paragraph position="4"> Let us compare the newly introduced cost and the</Paragraph>
      <Paragraph position="6"> effect of this revision. This revised version differs from the original in thai, it uses two dereference procedures that are tile same as tim original dereference procedure except that they use different fields. Thus, on the one hand, the overhead introduced to this revision is only the use of one additional field of the node structure. On the other hand, although this revised version does not introduce new data-structure sharing, it can safely' treat data-structure sharing in ini- null tial data structures. This can significantly reduce the amount of initial data structures required for linguistic descriptions, especiMly for lexical descriptions, and thus reduce garbage-collection and page-sw~q)ping.</Paragraph>
    </Section>
    <Section position="3" start_page="890" end_page="891" type="sub_section">
      <SectionTitle>
Revised LING Unification
</SectionTitle>
      <Paragraph position="0"> L\[N(I uniliet~tion is based on nondestructive unification and uses copy-dependency information to implement data-structure sharing. For a unique label arc, instead of its vMue being copied, the value itself is used as the output vMuc and copy-dependency relations are recorded to provide R)r later modification of shared structures. This algorithm uses a revised Copy~Node procedure that takes as its input two node structures (nodel and node2) and one arc structure, arc 1 where node.l is the node to be COl)ied. The structure arel is an arc to node J, and node t is an ancestor node of node.l -that is, the node fi'om which arel departs and the revised procedure is as follows: (i) if nodel' (the dereference result of node.t) is current, then Copy_Node returns nodel' to indicate that l, he ancestor node2 must be copied imme-.</Paragraph>
      <Paragraph position="1"> diately; otherwise, (ii) Copy_Arcs is applied to node l' and if it returns several arc copies, Copy_Node creates a new copy node and then adds to the new node the arc copies and arcs of node\[' that are not copied, and returns the ne.w node to indicate the aneestor node having to be coiffed immediately; otherwise, (iii) Copy_Node registors the copy-dependency between the nodel' and the ancestor node node2 that is, it adds the pair consisting of the ancestor node node2 a.nd the arc arc I into the copy field of node 1 'and returns Nil, to indicate that the ancestor must not be copied immediatelyfi When a new copy of a node is needed later, this algorithm will copy struceIn tile \],IN(-; unlfica.iton Mgorithm, ~t node structure's copy field is used to keep either copy iuform~ttion or copy-dependency inform~ttion. When tile', field keeps copy-dependency inform;ttion, its v~hle is a copydep structure consisting of an integer generation field- and a set of  tures by using the copy-depe,ldency information in its copy field (in the revised Get_Out_Node procedure for the 13NG unification). It substitutes arcs with newly copied nodes for existing arcs. Thus the antecedent nodes are also copied.</Paragraph>
      <Paragraph position="2"> The revised L\[NCI unification is based on the revised nondestructive unification and uses a node structure consisting of the fields in the node structure shown in Fig. 5 and a new field reuse \[br indicat node and arc pMrs -deps field (see Fig. 3). The technique used to control tile lifetime of copy-dependency information is tile same as tha.t of copy information. That is, the deps field value is meaningN1 only when the generation vadne is equM to the unification process identifier.</Paragraph>
      <Paragraph position="3">  ing data-structure sharing status. When the top-level unification procedure is invoked, it sets two new symbols to the two variables lused and fused. That a node structure has as its reuse field value the lused value means that it is used as part of the left input, and that it has as its reuse value the rused value means that it is used as part of the right input,. The revised LING unification uses two new revised Copy_Node procedures, Copy_Node_L (shown in Fig. 8) and the analogons preocedure Copy_Node_It These procedures are respectively used to treat the left and right inputs and they differ from the corresponding original procedure in two places. First, instead of step (i) above, if ~odel' (the dereference result of no&amp;l) is current, Cop?l_Node_l, (or Copy_Node_R) returns 7~ode l' to indicate that tire ancestor, node2, must be copied immediately. But if node1' has as its reuse field value the fused (or lused) value, it creates a copy of the whole subgraph whose root is nodel'and returns the eopied structure also to indica~,c that the ancestor node must be copied immediately. Second, in step (iii), they register data-structure sharing status that is, they set the lused (or fused) value to the reuse field of node l&amp;quot; as well as register copy-dependency information. This revised LING unification ensures safety in data-structure sharing.</Paragraph>
      <Paragraph position="4"> Again let us compare the newly introduced conrputational costs and the effect of l, his revision. The newly introduced costs are the additional cost of the revised dereference procedures (which is the same as in the previous one) and the cost of checking reuse status. The former cost is small, as shown in the discussion of the previous algorithm, ~nd the latter cost is also small. These costs are thus not significant relative to the efficiency gain obtained by this revision. Revised Quasi-Destructive Unification The strncture-sharillg version of quasi-destructive unification keeps update information in the field meaningful only during l, he unification. After a suceessful unification is obtained, this algorithm copies the unification result and attempts data-structure sharing. This algorithm can be revised to ensure safety in dal, a-structurc sharing hy using a node structure including two sets of fields for update information and one reuse field and by checking node reuse status while eopying.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>