<?xml version="1.0" standalone="yes"?>
<Paper uid="E95-1013">
  <Title>Literal Movement Grammars</Title>
  <Section position="4" start_page="93" end_page="95" type="metho">
    <SectionTitle>
3 Formal Properties
</SectionTitle>
    <Paragraph position="0"> The LMG formalism in its unrestricted form is shown to be Turing complete in (Groenink, 1995a). But the grammars presented in this paper satisfy a number of vital properties that allow for efficient parsing techniques. null Before building up material for a complexity result, notice the following proposition, which shows, using only part of the strength of the formalism, that the literal movement grammars are closed under intersection. null</Paragraph>
    <Paragraph position="2"> Clearly, GI recognizes precisely those sentences which are recognized by both G1 and Gz.</Paragraph>
    <Paragraph position="3"> We can use this knowledge in example 2.9 to restrict movement of verbs to verbs of finite morphology, by adding a nonterminal VFIN, replacing the quantifier items v:V that locate verb fillers with v:VFIN, where VFIN generates all finite verbs. Any extraposed verb will then be required to be in the intersection of VFIN and one of the verb types VI, VT or VR, reducing possible ambiguity and improving the efficiency of left-to-right recognition.</Paragraph>
    <Paragraph position="4"> The following properties allow us to define restrictions of the LMG formalism whose recognition problem has a polynomial time complexity.</Paragraph>
    <Paragraph position="6"> on the RHS of a rule is a single variable (i.e. we do not allow composite terms within predicates). If G is a non-combinatorial LMG, then any terminal string occurring (either as a sequence of items or inside a predicate) in a full G-derivation is a substring of the derived string. The grammar of example 2.8 is noncombinatorial; the grammar of example 2.9 is not (the offending rule is the first VP production).</Paragraph>
    <Paragraph position="7">  1 3.3 Definition (left-binding) An LMG G is left-binding when 1. W.r.t. argument positions, an item in the RHS of a rule only depends on variables bound in items to its left.</Paragraph>
    <Paragraph position="8"> 2. For any vector x ~ * * * x,~ of n &gt; 1 variables on the  LHS, each of xl upto xn-~ occurs in exactly one item, which is of the form qo/xl. Furthermore, for each 1 &lt; I &lt; k &lt; n the item referring to xz appears left of any item referring to x~.</Paragraph>
    <Paragraph position="9"> For example, the following rule is left binding: A(xyz, v) ~ u:B(v) C(v)/x DO/y E(u,z) but these ones are not:  (a) g(y) ---* C(x) x:D(y) (b) A(xy) ---* A(x) B(y) (c) A(xyz)~ A(z) BO/x CO/y  because in (a), x is bound right of its use; in (b), the item A(x) is not of the form qo/x and in (e), the variables in the vector zyz occur in the wrong order (zzy).</Paragraph>
    <Paragraph position="10"> Ifa grammar satisfies condition 1, then for any derivable string, there is a derivation such that the modus ponens and elimination rules are always applied to the leftmost item that is not a terminal. Furthermore, the :E rule can be simplified to :E G The proof tree in example 2.8 (figure 1) is an example of such a derivation.</Paragraph>
    <Paragraph position="11"> Condition 2 eliminates the nondeterminism in finding the right instantiation for rules with multiple variable patterns in their LHS.</Paragraph>
    <Paragraph position="12"> Both grammars from section 2 are left-binding. 1 3.4 Definition (left-recursive) An LMG G is left-recursive if there exists an instantiated nonterminal G predicate qa such that there is a derivation of ~o ~ ~pc~ for any sequence of items c~.</Paragraph>
    <Paragraph position="13"> The following two rules show that left-recursion in  We now show that the recognition problem for an arbitrary left-binding, non-combinatorial LMG has a polynomial worst-case time complexity.</Paragraph>
    <Paragraph position="14"> 1 3.5 Theorem (polynomial complexity) Let G be a LMG of similarity type # that is noncombinatorial, left binding and not left-recursive. Let m be the maximum number of items on the right hand side of rules in G, and let p be the greatest arity of predicates occurring in G. Then the worst case time complexity of the recognition problem for G does not exceed O(IGIm(1 + p)nl+'~+2P), where n is the size of the input string ala2&amp;quot; * .a,~.</Paragraph>
    <Paragraph position="15"> Proof (sketch) We adopt the memoizing recursive descent algorithm presented in (Leermakers, 1993). As G is not left-binding, the terminal words associated with variables occurring in the grammar rules can be fully determined while proceeding through sentence and rules from left to right. Because the grammar is non-combinatorial, the terminal words substituted in the argument positions of a nonterminal are always substrings of the input sentence, and can hence be represented as a pair of integers.</Paragraph>
    <Paragraph position="16"> The recursive descent algorithm recursively computes set-valued recognition functions of the form:</Paragraph>
    <Paragraph position="18"> where instead of a nonterminal as in the context-free case, qo is any instantiated nonterminal predicate A(bl,..., b,~). As bl,...,b,~ are continuous sub-strings of the input sentence ala2 * * * an, we can reformulate this as \[A\](i, (tl, r,),..., r,,)) = {jlA(ah+ 1...a,,,,...,at.+l...ar~) ai+ 1 * *. aj } Where # = #(A) &lt; p. The arguments i, ll,...,l~, and rl,. *., r t, are integer numbers ranging from 0 to n - 1 and 1 to n respectively. Once a result of such a recognition function has been computed, it is stored in a place where it can be retrieved in one atomic operation. The number of such results to be stored is O(n) for each possible nonterminal and each possible combination of, at most 1 + 2p, arguments; so the total space complexity is O(IGIn2+2p).</Paragraph>
    <Paragraph position="19"> Much of the extra complication w.r.t, the context-free case is coped with at compile time; for example, if there is one rule for nonterminal A:</Paragraph>
    <Paragraph position="21"> then the code for \[g\](i, (ll, r,), (12, r2)) will be</Paragraph>
    <Paragraph position="23"> rot e for k 3 e \[B3\](/2, (/3, r3)) if (k 3 =: r2) add k2 to result return result The extra effort remaining at parse time is in copying arguments and an occasional extra comparison (the if statement in the example), taking rn(1 + p) steps everytime the innermost for statement is reached, and the fact that not O(n), but O(n l+2p) argumentvalue pairs need to be memoized. Merging the results in a RHS sequence of rn items can be done in O(m(1 + p)n ~-1) time. The result is a set of O(n) size. As there are at most O(IGln 1+2p) results to be computed, the overall time complexity of the algorithm</Paragraph>
    <Paragraph position="25"> nullary (p = 0), then the complexity result coincides with the values found for the context-free recursive descent algorithm (Leermakers, 1993). Nullary LMG includes the context-free case, but still allows movement local to a rule; the closure result 3.1 still holds for this class of grammars. As all we can do with binding and slashing local to a rule is intersection, the nullary LMGs must be precisely the closure of the context-free grammars under finite intersection.</Paragraph>
    <Paragraph position="26"> These results can be extended to more efficient algorithms which can cope with left-recursive grammars such as memoizing recursive ascent (Leermakers, 1993). A very simple improvement is obtained by bilinearizing the grammar (which is possible if it  is left binding), giving a worst case complexity of o(Ic\[(1 + p)n3+2,).</Paragraph>
  </Section>
  <Section position="5" start_page="95" end_page="95" type="metho">
    <SectionTitle>
4 Other Approaches to Separation of
</SectionTitle>
    <Paragraph position="0"/>
    <Section position="1" start_page="95" end_page="95" type="sub_section">
      <SectionTitle>
Movement
</SectionTitle>
      <Paragraph position="0"> A natural question to ask is whether the LMG formalism (for the purpose of embedding in equational specification systems, or eliminating unification as a stage of sentence processing) really has an advantage over existing mildly context-sensitive approaches to movement. Other non-concatenative formalisms are head-wrapping grammars (HG) (Pollard, 1984), extraposition grammars (XG) (Pereira, 1981) and various exotic forms of tree adjoining grammar (Kroch and Joshi, 1986). For overviews see (Weir, 1988), (Vijay-Shanker et al., 1986) and (van Noord, 1993). The most applicable of these formalisms for our purposes seem to be HG and XG, as both of these show good results in modeling movement phenomena, and both are similar in appearance to context-free grammars; as in LMG, a context-free grammar has literally the same representation when expressed in HG or XG. Hence it is to be expected that incorporating these approaches into a system based on a context-free front-end will not require a radical change of perspective.</Paragraph>
    </Section>
    <Section position="2" start_page="95" end_page="95" type="sub_section">
      <SectionTitle>
4.1 Head Grammars
</SectionTitle>
      <Paragraph position="0"> A notion that plays an important role in various forms of Linguistic theory is that of a head. Although there is a great variation in the form and function of heads in different theories, in general we might say that the head of a constituent is the key component of that constituent. The head grammar formalism, introduced by Pollard in (Pollard, 1984) divides a constituent into three components: a left context, a terminal head and a right context. In a HG rewrite rule these parts of a constituent can be addressed separately when building a constituent from a number of subconstituents.</Paragraph>
      <Paragraph position="1"> An accurate and elegant account of Dutch cross-serial dependencies using HG is sketched in (Pollard, 1984). However, we have not been able to construct head grammars that are able to model verb movement, cross-serial dependencies and topicalization at the same time. For every type of constituent, there is only one head, and hence only one element of the constituent that can be the subject to movement. 3</Paragraph>
    </Section>
    <Section position="3" start_page="95" end_page="95" type="sub_section">
      <SectionTitle>
4.2 Extraposition Grammars
</SectionTitle>
      <Paragraph position="0"> Whereas head grammars provide for an account of verb fronting and cross-serial dependencies, Pereira, 3However, a straightforward extension of head grammars defined in (Groenink, 1995a) which makes use of arbitrary tupies, rather than dividing constituents into three components, is (1) capable of representing the three target phenomena of Dutch all at once and (2) weakly equivalent to a (strongly limiting) restriction of literal movement grammars. Head grammars and their generalizations, being linear context-free rewriting systems (Weir, 1988), have been shown to have polynomial complexity.</Paragraph>
      <Paragraph position="1"> introducing extraposition grammars in (Pereira, 1981), is focused on displacement of noun phrases in English.</Paragraph>
      <Paragraph position="2"> Extraposition grammars are in appearance very similar to context-free grammars, but allow for larger patterns on the left hand side of PS rules. This makes it possible to allow a topicalized NP only if somewhere to its right there is an unfilled trace:</Paragraph>
      <Paragraph position="4"> While XG allows for elegant accounts of cross-serial dependencies and topicalization, it seems again hard to simultaneously account for verb and noun movement, especially if the bracketing constraint introduced in (Pereira, 1981), which requires that XG derivation graphs have a planar representation, is not relaxed. 4 Furthermore, the practical application of XG seems to be a problem. First, it is not obvious how we should interpret XG derivation graphs for further analysis.</Paragraph>
      <Paragraph position="5"> Second, as Pereira points out, it is nontrivial to make the connection between the XG formalism and standard (e.g. Earley-based) parsing strategies so as to obtain truly efficient implementations.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>