<?xml version="1.0" standalone="yes"?>
<Paper uid="P03-2036">
  <Title>Comparison between CFG filtering techniques for LTAG and HPSG</Title>
  <Section position="3" start_page="0" end_page="0" type="intro">
    <SectionTitle>
2 Background
</SectionTitle>
    <Paragraph position="0"> In this section, we introduce a grammar conversion (Yoshinaga and Miyao, 2001) and CFG filtering (Harbusch, 1990; Poller and Becker, 1998; Torisawa et al., 2000; Kiefer and Krieger, 2000).</Paragraph>
    <Section position="1" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.1 Grammar conversion
</SectionTitle>
      <Paragraph position="0"> The grammar conversion consists of a conversion of LTAG elementary trees to HPSG lexical entries and an emulation of substitution and adjunction by</Paragraph>
      <Paragraph position="2"> trees of depth n(,1) contain at least one anchor. A canonical elementary tree is then converted into an HPSG lexical entry by regarding the leaf nodes as arguments and by storing them in a stack.</Paragraph>
      <Paragraph position="3"> We can perform a comparison between LTAG and HPSG parsers using strongly equivalent grammars obtained by the above conversion. This is because strongly equivalent grammars can be a substitute for the same grammar in different grammar formalisms.</Paragraph>
    </Section>
    <Section position="2" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.2 CFG filtering techniques
</SectionTitle>
      <Paragraph position="0"> An initial offline step of CFG filtering is performed to approximate a given grammar with a CFG. The obtained CFG is used as an efficient device to compute the necessary conditions for parse trees.</Paragraph>
      <Paragraph position="1"> The CFG filtering generally consists of two steps.</Paragraph>
      <Paragraph position="2"> In phase 1, the parser first predicts possible parse trees using the approximated CFG, and then filters out irrelevant edges by a top-down traversal starting from roots of successful context-free derivations. In phase 2, it then eliminates invalid parse trees by using constraints in the given grammar. We call the remaining edges that are used for the phase 2 parsing essential edges.</Paragraph>
      <Paragraph position="3"> The parsers with CFG filtering used in our experiments follow the above parsing strategy, but are different in the way the CF approximation and the elimination of impossible parse trees in phase 2 are performed. In the following sections, we briefly describe the CF approximation and the elimination of impossible parse trees in each realization.</Paragraph>
      <Paragraph position="4">  In CFG filtering techniques for LTAG (Harbusch, 1990; Poller and Becker, 1998), every branching of elementary trees in a given grammar is extracted as a CFG rule as shown in Figure 1.</Paragraph>
      <Paragraph position="5"> G r a m m a r r u l e l e x i c a lS Y N S E M ...</Paragraph>
      <Paragraph position="6"> s i g nS Y N S E M ...s i g nS Y N S E M ...</Paragraph>
      <Paragraph position="7"> p h r a s a lS Y N S E M ...</Paragraph>
      <Paragraph position="8"> G r a m m a r r u l e p h r a s a lS Y N S E M ...</Paragraph>
      <Paragraph position="9"> s i g nS Y N S E M ...s i g nS Y N S E M ...</Paragraph>
      <Paragraph position="10"> p h r a s a lS Y N S E M ...</Paragraph>
      <Paragraph position="11"> p h r a s a lS Y N S E M ...</Paragraph>
      <Paragraph position="12">  Because the obtained CFG can reflect only local constraints given in each local structure of the elementary trees, it generates invalid parse trees that connect local trees in different elementary trees. In order to eliminate such parse trees, a link between branchings is preserved as a node number which records a unique node address (a subscript attached to each node in Figure 1). We can eliminate these parse trees by traversing essential edges in a bottom-up manner and recursively propagating ok-flag from a node number x to a node number y when a connection between x and y is allowed in the LTAG grammar. We call this propagation ok-prop.</Paragraph>
      <Paragraph position="13">  In CFG filtering techniques for HPSG (Torisawa et al., 2000; Kiefer and Krieger, 2000), the extraction process of a CFG from a given HPSG grammar starts by recursively instantiating daughters of a grammar rule with lexical entries and generated feature structures until new feature structures are not generated as shown in Figure 2. We must impose restrictions on values of some features (i.e., ignoring them) and/or the number of rule applications in order to guarantee the termination of the rule application. A CFG is obtained by regarding each initial and generated feature structures as nonterminals and transition relations between them as CFG rules.</Paragraph>
      <Paragraph position="14"> Although the obtained CFG can reflect local and global constraints given in the whole structure of lexical entries, it generates invalid parse trees because they do not reflect upon constraints given by the values of features that are ignored in phase 1. These parse trees are eliminated in phase 2 by applying a grammar rule that corresponds to the applied CFG rule. We call this rule application rule-app.</Paragraph>
      <Paragraph position="15">  plates) and approximated CFGs (above: the number of nonterminals; below: the number of rules)  In this section, we compare a pair of CFG filtering techniques for LTAG (Poller and Becker, 1998) and HPSG (Torisawa et al., 2000) described in Section 2.2.1 and 2.2.2. We hereafter refer to PB and TNT for the C++ implementations of the former and a valiant1 of the latter, respectively.2 We first acquired LTAGs by a method proposed in Miyao et al. (2003) from Sections 2-21 of the Wall Street Journal (WSJ) in the Penn Tree-bank (Marcus et al., 1993) and its subsets.3 We then converted them into strongly equivalent HPSG-style grammars using the grammar conversion described in Section 2.1. Table 1 shows the size of CFG approximated from the strongly equivalent grammars. Gx, CFGPB, and CFGTNT henceforth refer to the LTAG extracted from Section x of WSJ and CFGs approximated from Gx by PB and TNT, respectively.</Paragraph>
      <Paragraph position="16"> The size of CFGTNT is much larger than that of CFGPB. By investigating parsing performance using these CFGs, we show that the larger size of CFGTNT resulted in better parsing performance.</Paragraph>
      <Paragraph position="17"> Table 2 shows the parse time with 254 sentences of length n (*10) from Section 2 of WSJ (the average length is 6.72 words).4 This result shows not only that TNT achieved a drastic speed-up against  PB, but also that performance difference between them increases with the larger size of the grammars. In order to estimate the degree of CF approximation, we measured the number of essential (inactive) edges of phase 1. Table 3 shows the number of the essential edges. The number of essential edges produced by PB is much larger than that produced by TNT. We then investigated the effect on phase 2 as caused by the different number of the essential edges. Table 4 shows the success rate of ok-prop and rule-app. The success rate of rule-app is 100%,5 whereas that of ok-prop is quite low.6 These results indicate that CFGTNT is superior to CFGPB with respect to the degree of the CF approximation.</Paragraph>
      <Paragraph position="18"> We can explain the reason for this difference by investigating how TNT approximates HPSG-style grammars converted from LTAGs. As described in Section 2.1, the grammar conversion preserves the whole structure of each elementary tree (precisely, a canonical elementary tree) in a stack, and grammar rules manipulate a head element of the stack. A generated feature structure in the approximation process thus corresponds to the whole unprocessed portion of a canonical elementary tree. This implies that successful context-free derivations obtained by CFGTNT basically involve elementary trees in which all substitution and adjunction have succeeded. However, CFGPB (also a CFG produced by the other work (Harbusch, 1990)) cannot avoid generating invalid parse trees that connect two lo- null using the XTAG English grammar (The XTAG Research Group, 2001) without features (parse time (sec.)/success rate (%) for PB and TNT were 15.3/30.6 and 0.606/71.2 with the same sentences), though space limitations preclude complete results. cal structures where adjunction takes place between them. We measured with G2-21 the proportion of the number of ok-prop between two node numbers of nodes that take adjunction and its success rate. It occupied 87% of the total number of ok-prop and its success rate was only 22%. These results suggest that the global contexts in a given grammar is essential to obtain an effective CFG filter.</Paragraph>
      <Paragraph position="19"> It should be noted that the above investigation also tells us another way of CF approximation of LTAG.</Paragraph>
      <Paragraph position="20"> We first define a unique way of tree traversal such as head-corner traversal (van Noord, 1994) on which we can perform a sequential application of substitution and adjunction. We then recursively apply substitution and adjunction on that traversal to an elementary tree and a generated tree structure. Because the processed portions of generated tree structures are no longer used later, we regard the unprocessed portions of the tree structures as nonterminals of CFG. We can thereby construct another CFG filtering for LTAG by combining this CFG filter with an existing LTAG parsing algorithm (van Noord, 1994).</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>