<?xml version="1.0" standalone="yes"?>
<Paper uid="P91-1015">
  <Title>Head Corner Parsing for Discontinuous Constituency</Title>
  <Section position="2" start_page="0" end_page="115" type="intro">
    <SectionTitle>
1 Introduction
</SectionTitle>
    <Paragraph position="0"> Although most formalisms in computational linguistics assume that phrases are built by string concatenation (eg. as in PATR II, GPSG, LFG and most versions of Categorial Grammar), this assumption is challenged in non-concatenative grammatical formalisms. In Pollard's dissertation several versions of 'qlead wrapping&amp;quot; are defined (Pollard, 1984). In the analysis of the Australian free word-order language Guugu Yimidhirr, Mark Johnson uses a 'combine' predicate in a DCG-like grammar that corresponds to the union of words (Johnson, 1985).</Paragraph>
    <Paragraph position="1"> Mike Reape uses an operation called 'sequence union' to analyse Germanic semi-free word order constructions (l~ape, 1989; Reape, 1990a).</Paragraph>
    <Paragraph position="2"> Other examples include Tree Adjoining Grammars (Joshi et al., 1975; Vijay-Shankar and Joshi, 1988), and versions of Categorial Grammar (Dowry, 1990) and references cited there.</Paragraph>
    <Paragraph position="3"> Motivation. There are several motivations for non-concatenative grammars. First, specialized string combination operations allow elegant linguistic accounts of phenomena that are otherwise notoriously hard. Examples are the analyses of Dutch cross serial dependencies by head wrapping or sequence union (Reape, 1990a).</Paragraph>
    <Paragraph position="4"> Furthermore, in non-concatenative grammars it is possible to relate (parts of) constituents that belong together semantically, but which are not adjacent. Hence such grammars facilitate a simple compositional semantics. In CF-based grammars such phenomena usually are treated by complex 'threading' mechanisms.</Paragraph>
    <Paragraph position="5"> Non-concatenative grammatical formalisms may also be attractive from a computational point of view. It is easier to define generation algorithms if the semantics is built in a systematically constrained way (van Noord, 1990b). The semantic-head-driven generation strategy (van Noord, 1989; Calder ef al., 1989; Shieber et al., 1989; van Noord, 1990a; Shieber et al., 1990) faces problems in case semantic heads are 'displaced', and this displacement is analyzed using threading. However, in this paper I sketch a simple analysis of verb-second (an example of a displacement of semantic heads) by an operation similar to head wrapping which a head-driven generator processes without any problems (or extensions) at all. Clearly, there are also some computational problems, because most 'standard' parsing strategies assume context-free concatenation of strings. These problems are the subject of this paper.</Paragraph>
    <Paragraph position="6"> The task. I will restrict the attention to a class of constraint-based formalisms, in which operations on strings are defined that are more powerful than concatenation, but which operations are restricted to be nonerasing, and linear. The resulting class of systems can be characterized as Linear Context-Free Rewriting Systems  (LCFRS), augmented with feature-structures (F-LCFRS). For a discussion of the properties of LCFRS without feature-structures, see (Vijay-Shanker et al., 1987). Note though that these properties do not carry over to the current system, because of the augmention with feature structures.</Paragraph>
    <Paragraph position="7"> As in LCFRS, the operations on strings in F-LCFRS can be characterized as follows. First, derived structures will be mapped onto a set of occurances of words; i.e. each derived structure 'knows' which words it 'dominates'. For example, each derived feature structure may contain an attribute 'phon' whose value is a list of atoms representing the string it dominates. I will write w(F) for the set of occurances of words that the derived structure F dominates. Rules combine structures D1 ... Dn into a new structure M. Nonerasure requires that the union of w applied to each daughter is a subset of w(M):</Paragraph>
    <Paragraph position="9"> Linearity requires that the difference of the cardinalities of these sets is a constant factor; i.e. a rule may only introduce a fixed number of words syncategorematically:</Paragraph>
    <Paragraph position="11"> CF-based formalisms clearly fulfill this requirement, as do Head Grammars, grammars using sequence union, and TAG's. I assume in the remainder of this paper that I.Jin=l w(Di) = w(M), for all rules other than lexical entries (i.e. all words are introduced on a terminal). Note though that a simple generalization of the algorithm presented below handles the general case (along the lines of Shieber et al. (1989; 1990)by treating rules that introduce extra lexical material as nonchain-rules). null Furthermore, I will assume that each rule has a designated daughter, called the head. Although I will not impose any restrictions on the head, it will turn out that the parsing strategy to be proposed will be very sensitive to the choice of heads, with the effect that F-LCFRS's in which the notion 'head' is defined in a systematic way (Pollard's Head Grammars, Reape's version of HPSG, Dowty's version of Categorial Grammar), may be much more efficiently parsed than other grammars. The notion seed of a parse tree is defined recursively in terms of the head. The seed of a tree will be the seed of its head. The seed of a terminal will be that terminal itself.</Paragraph>
    <Paragraph position="12"> Other approaches. In (Proudian and Pollard, 1985) a head-driven algorithm based on active chart parsing is described. The details of the algorithm are unclear from the paper which makes a comparison with our approach hard; it is not clear whether the parser indeed allows for example the head-wrapping operations of Pollard (1984). Reape presented two algorithms (Reape, 1990b) which are generalizations of a shift-reduce parser, and the CKY algorithm, for the same class of grammars. I present a head-driven bottom-up algorithm for F-LCFR grammars. The algorithm resembles the head-driven parser by Martin Kay (Kay, 1989), but is generalized in order to be used for this larger class of grammars. The disadvantages Kay noted for his parser do not carry over to this generalized version, as redundant search paths for CF-based grammars turn out to be genuine parts of the search space for F-LCFR grammars. null The advantage of my algorithm is that it both employs bottom-up and top-down filtering in a straightforward way. The algorithm is closely related to head-driven generators (van Noord, 1989; Calder et al., 1989; Shieber et al., 1989; van Noord, 1990a; Shieber et ai., 1990). The algorithm proceeds in a bottom-up, head-driven fashion. In modern linguistic theories very much information is defined in lexical entries, whereas rules are reduced to very general (and very uninformative) schemata. More information usually implies less search space, hence it is sensible to parse bottom-up in order to obtain useful information as soon as possible. Furthermore, in many linguistic theories a special daughter called the head determines what kind of other daughters there may be. Therefore, it is also sensible to start with the head in order to know for what else you have to look for. As the parser proceeds from head to head it is furthermore possible to use powerful top-down predictions based on the usual head feature percolations. Finally note that proceding bottom-up solves some non-termination problems, because in lexicalized theories it is often the case that information in lexical entries limit the recursive application of rules (eg. the size of the subcat list of  an entry determines the depth of the derivation tree of which this entry can be the seed).</Paragraph>
    <Paragraph position="13"> Before I present the parser in section 3, I will first present an example of a F-LCFR grammar, to obtain a flavor of the type of problems the parser handles reasonably well.</Paragraph>
  </Section>
class="xml-element"></Paper>