<?xml version="1.0" standalone="yes"?>
<Paper uid="P99-1075">
  <Title>Packing of Feature Structures for Efficient Unification of Disjunctive Feature Structures</Title>
  <Section position="3" start_page="0" end_page="582" type="metho">
    <SectionTitle>
2 Data Structure and Algorithms
</SectionTitle>
    <Paragraph position="0"> This section describes the data structure of packed feature structures, and the algorithms for packing and unification of packed feature structures. Through of this section, I will refer to examples from the XHPSG system (Tateisi</Paragraph>
    <Paragraph position="2"> Figure 1:4 out of 37 lexical entries which the XHPSG system assigns to the word &amp;quot;credited&amp;quot;.</Paragraph>
    <Paragraph position="3"> Parts shaded with the same pattern are equivalent.</Paragraph>
    <Paragraph position="4"> et al., 1998), an HPSG-based grammar for English. null</Paragraph>
    <Section position="1" start_page="579" end_page="580" type="sub_section">
      <SectionTitle>
2.1 Packed Feature Structure
</SectionTitle>
      <Paragraph position="0"> Figure 1 shows 4 out of 37 lexical entries which the XHPSG system assigns to the word &amp;quot;credited&amp;quot;. These lexical entries have various equivalent parts in their respective feature structures.</Paragraph>
      <Paragraph position="1"> In Figure 1, equivalent parts are shaded with the same pattern.</Paragraph>
      <Paragraph position="2"> Figure 2 shows a packed feature structure for the lexical entries shown in Figure 1. Note that the equivalent parts of the original feature structures are collapsed into a feature structure segment, which is denoted by Si in Figure 2. So is a special segment called the root segment, which</Paragraph>
      <Paragraph position="4"> the same information as the set of feature structures in Figure 1. Shaded parts correspond to the parts with the same pattern in Figure 1.</Paragraph>
      <Paragraph position="5"> describes the root nodes of all original feature structures. Each segment can have disjunctive nodes, which are denoted by Ai. For example, 53 has two disjunctive nodes, A 5 and A6. A dependency function, denoted by Di, is a mapping from a disjunctive node to a segment, and each Di corresponds to one original feature structure.</Paragraph>
      <Paragraph position="6"> We can obtain each original feature structure by replacing each disjunctive node with the output of the respective dependency function.</Paragraph>
      <Paragraph position="7"> For applying the unification algorithm described in Section 2.3, we introduce a condition on segments: a segment cannot have inter- or intra-segment shared nodes. For example, the disjunctive node i 1 in Figure 2 must be introduced for satisfying this condition, even though the value of this node is the same in all the original feature structures. This is because this path is structure-shared with another path (SYNSEHILOCALJCONT j ARG1 and SYNSEHJLOCALJCONTJARG2). Structure-sharing in original feature structures is instead expressed by letting the dependency function return the same value for different inputs. For example, result values of applying D1 to A1 and A7 are both S1.</Paragraph>
      <Paragraph position="8"> The reason why we introduce this condition is to guarantee that a disjunctive node in the  unified with the top feature structure in Figure 1, a new disjunctive node must he introduced to SYNSRM I LOCALICATJVALJSUBJ IFIRSTICONT.</Paragraph>
      <Paragraph position="9"> result of unification will appear only at a path where a disjunctive node appears in either of the input feature structures at the same path. For example, suppose we unify the top feature structure in Figure 1 with the packed feature structure in Figure 3. In the result of unification, a new disjunctive node must appear at SYNSEM I LOCALJCATIVALJSUBJJFIRSTJCONT , while no disjunctive nodes appear in either of the input feature structures at this path. By introducing such a disjunctive node in advance, we can simplify the algorithm for unification described in Section 2.3.</Paragraph>
      <Paragraph position="10"> Below I first describe the algorithm for packing feature structures, and then the algorithm for unification of packed feature structures.</Paragraph>
    </Section>
    <Section position="2" start_page="580" end_page="580" type="sub_section">
      <SectionTitle>
2.2 Algorithm for Packing
</SectionTitle>
      <Paragraph position="0"> The procedure pack_feature_structures in Figure 4 describes the algorithm for packing two packed feature structures, denoted by (S',:D') and (,9&amp;quot;, D&amp;quot;). ,9' and S&amp;quot; denote sets of segments, and 7)' and 7)&amp;quot; denote sets of dependency functions. We start from comparing the types of the root nodes of both feature structures. If either of the nodes is a disjunctive node (Case 1 ), we compare the type of the other feature structure with the type of each disjunct, and recursively pack nodes with the same type if they exist (Case 1.1). Otherwise, we just add the other feature structure to the disjunctive node as a new disjunct (Case 1.2). If the types of the nodes are equivalent (Case 2), we collapse them into one node, and apply packing recursively to all of their subnodes. If they are not equivalent (Case 3), we create a new disjunctive node at this node, and let each original</Paragraph>
      <Paragraph position="2"> disjuucts: return a set of disjuncts of the disjunctive node :features: return a set of features :folios: return a substructure reached by the specified feature  feature structure from this node become a new segment.</Paragraph>
      <Paragraph position="3"> For simplicity, Figure 4 omits the algorithm for introducing disjunctive nodes into shared nodes. We can easily create disjunctive nodes in such places by preprocessing input feature structures in the following way. First each input feature structure is converted to a packed feature structure in advance by converting shared nodes to disjunctive nodes. Then the above algorithm can be applied to these converted packed feature structures.</Paragraph>
    </Section>
    <Section position="3" start_page="580" end_page="582" type="sub_section">
      <SectionTitle>
2.3 Algorithm for Unification
</SectionTitle>
      <Paragraph position="0"> Below I describe the algorithm for unification of packed feature structures, referring to the example in Figure 2. Suppose that we are unifying this packed feature structure with the feature structure in Figure 5. This example considers unification of a non-packed feature structure with a packed feature structure, although this algorithm is capable of unifying two packed feature structures.</Paragraph>
      <Paragraph position="1"> The process itself is described by the procedure unify_packed_feature_structures in Figure 6. It is quite similar to a normal uni-</Paragraph>
      <Paragraph position="3"> already-unified: t~e when unification is already computed res~ere_uui~y_result: restore the result of unific&amp;tion from the table seS_unify.xesul~: store the result of unification into the table unifyJype: return the unification of both types  part that handles disjunctive nodes. When we reach a disjunctive node, we put it onto a stack (segment_stack), and postpone further unification from this node ((5) in Figure 6). In this example, we put A1, A2, A3, and A4 onto the stack. At the end of the entire unification, we  ing A 1 with \[~. Disjunction is expressed by non-determinism when applying the dependency functions. When we unify a feature structure segment for A2, we unify $2 if we are applying Dz, or 53 if D2.</Paragraph>
      <Paragraph position="4"> apply a dependency function to each member of the stack, and unify every resulting segment with a corresponding part of the other feature structure ((1) in Figure 6). In this example, we apply D1 to A1, which returns segment 51.</Paragraph>
      <Paragraph position="5"> We therefore unify 5z with the feature structure tagged as \[~\] in Figure 5.</Paragraph>
      <Paragraph position="6"> Disjunction is expressed by non-determinism when applying the dependency functions. Figure 7 shows the intermediate data structure after unifying A1 with \[~\]. We are now focusing on the disjunctive node A2 which is now on the top of segment_stack. When we are applying Dz, we unify $2 with the corresponding feature structure \[~\]. Should we instead apply D2, 53 would be unified.</Paragraph>
      <Paragraph position="7"> A benefit of this unification algorithm is that we can skip unification of feature structure segments whose unification is already computed ((2) in Figure 6). For example, we unify segment So with the other feature structure only once. We can also skip unification of $1 and 5z0 for /:)2, because the result is already computed  fication of A4. Because the result of applying Dz to AT is already overwritten by the result of unifying 51 within\], we unify this resulting feature structure with ff\]y for D1. This operation preserves the validity of unification because each segment does not have inter- or intra-segment shared nodes, because of the condition we previously introduced.</Paragraph>
      <Paragraph position="8"> Note that this method can correctly unify feature structures with reentrancies. For example, Figure 8 shows the intermediate data structure after unifying A4, and the process currently reached A7 and E\]&amp;quot; The result of the application of D1 to A7 is the result of unifying Sz with \[~, because Sz is overwritten with the result of this previous unification ((3) and (4) in Figure 6). Hence, we unify E\] with this result. Above unification algorithm is applied to every combination of dependency functions. The result of the entire unification is shown in Figure 9.</Paragraph>
    </Section>
  </Section>
  <Section position="4" start_page="582" end_page="582" type="metho">
    <SectionTitle>
3 Experiments
</SectionTitle>
    <Paragraph position="0"> I implemented the algorithms for packing and unification in LiLFeS (Makino et al., 1998).</Paragraph>
    <Paragraph position="1"> LiLFeS is one of the fastest inference engines for processing feature structure logic, and efficient parsers have already been realized using this system. For performance evaluation I measure the execution time for a part of application of grammar rules (i.e. schemata) of XHPSG.</Paragraph>
    <Paragraph position="2"> Table 1 shows the execution time for unifying the resulting feature structure of apply- null of unifying the packed feature structure of Figure 2 with the feature structure of Figure 5.</Paragraph>
    <Paragraph position="3"> ing schemata to lexical entries of &amp;quot;Mary&amp;quot; as a left daughter, with lexical entries of &amp;quot;credited&amp;quot;/&amp;quot;walked&amp;quot; as right daughters. Unification of packed feature structures achieved a speed-up by a factor of 6.4 to 8.4, compared to the naive approach. Table 2 shows the number of unification routine calls. NODE_UNIFY shows the number of nodes for which unification of types is computed. As can be seen, it is significantly reduced. On the other hand, SEGNENT_UNIFY shows the number of check operations whether unification is already computed. It shows that the number of node unification operations is significantly reduced by the packing method, and segment unification operations account for most of the time taken by the unification.</Paragraph>
    <Paragraph position="4"> These results indicate that a unification speed can be improved furthermore by reducing the number of the segment unification. The data structure of dependency functions has to be improved, and dependency functions can be packed. I observed that at least a quarter of the segment unification operations can be suppressed. This is one of the future works.</Paragraph>
  </Section>
class="xml-element"></Paper>