<?xml version="1.0" standalone="yes"?>
<Paper uid="P94-1021">
  <Title>Constraint-Based Categorial Grammar Gosse Bouma and Gertjan van Noord Alfa-informatica and Behavorial and Cognitive Neurosciences,</Title>
  <Section position="6" start_page="150" end_page="152" type="evalu">
    <SectionTitle>
4 Processing
</SectionTitle>
    <Paragraph position="0"> The introduction of recursive lexical rules has repercussions for processing as they lead to an infinite number of lexical categories for a given lexical item or, if one  considers lexical rules as unary syntactic rules, to non-branching derivations of unbounded length. In both cases, a parser may not terminate. One of the main advantages of modeling lexical rules by means of constraints is that it suggests a solution for this problem. A control strategy which delays the evaluation of constraints until certain crucial bits of information are filled in avoids non-termination and in practice leads to grammars in which all constraints are fully evaluated at the end of the parse-process.</Paragraph>
    <Paragraph position="1"> Consider a grammar in which the only recursive constraint is add_adjuncts, as defined in section 2.2. The introduction of recursive constraints in itself does not solve the non-termination problem. If all solutions for add_adjuncts are simply enumerated during lexical look-up an infinite number of categories for any given verb will result.</Paragraph>
    <Paragraph position="2"> During processing, however, it is not necessarily the case that we need to consider all solutions. Syntactic processing can lead to a (partial) instantiation of the arguments of a constraint. If the right pieces of information are instantiated, the constraint will only have a finite number of solutions.</Paragraph>
    <Paragraph position="3"> Consider, for instance, a parse for the following string.</Paragraph>
    <Paragraph position="4"> (22) ... J. opzettelijk een ongeluk veroorzaakt  Even if the category of the verb is left completely open initially, there is only one derivation for this string that reduces to S (remember that the syntax uses application only). This derivation provides the information that the variable Verb must be a transitive verb selecting one additional adjunct, and with this information it is easy to check whether the following constraint is satisfied: add_adjuncts(NP\(ADJ\(NP\S) ), NP\(NP\S)).</Paragraph>
    <Paragraph position="5"> This suggests that recursive constraints should not be evaluated during lexical look-up, but that their evaluation should be delayed until the arguments are sufficiently instantiated.</Paragraph>
    <Paragraph position="6"> To implement this delayed evaluation strategy, we used the block facility of Sicstus Prolog. For each recursive constraint, a block declaration defines what the conditions are under which it may be evaluated. The definition of add_adjuncts (with semantics omitted for readability), for instance, now becomes:  (23) add_adjuncts(\[ arg Arg \]x,Y) :add_adjuncts(X, Y, Arg).</Paragraph>
    <Paragraph position="7"> * - block add_adjuncts(?,?,-).</Paragraph>
    <Paragraph position="8"> add_adjuncts(S, S, _).</Paragraph>
    <Paragraph position="9"> add_adjuncts(Adj \X, Y, _) : null add_adjuncts(X, Y). ivy, x\] \[w,Y\] add_adjuncts( dir D , dir D ,.A.) :arg A arg A add_adjuncts(X, Y).</Paragraph>
    <Paragraph position="10"> We use add_adjuncts~2 to extract the information that determines when add_adjuncts/3 is to be evaluated. The block declaration states that add_adjuncts/3 may only be evaluated if the third argument (i.e. the argument of the 'output' category) is not a variable. During lexical look-up, this argument is uninstantiated, and thus, no evaluation takes place. As soon as a verb combines with an argument, the argument category of the verb is instantiated and add_adjuncts~3 will be evaluated. Note, however, that calls to add_adjuncts~3 are recursive, and thus one evaluation step may lead to another call to add_adjuncts~3, which in its turn will be blocked until the argument has been instantiated sufficiently. Thus, the recursive constraint is evaluated incrementally, with each syntactic application step leading to a new evaluation step of the blocked constraint. The recursion will stop if an atomic category s is found. Delayed evaluation leads to a processing model in which the evaluation of lexieal constraints and the construction of derivational structure is completely intertwined. null</Paragraph>
    <Section position="1" start_page="151" end_page="152" type="sub_section">
      <SectionTitle>
4.1 Other strategies
</SectionTitle>
      <Paragraph position="0"> The delayed evaluation techniques discussed above can be easily implemented in parsers which rely on back-tracking for their search. For the grammars that we have worked with, a simple bottom-up (shift-reduce) parser combined with delayed evaluation guarantees termination of the parsing process.</Paragraph>
      <Paragraph position="1"> To obtain an efficient parser more complicated search strategies are required. However, chart-based search techniques are not easily generalized for grammars which make use of complex constraints. Even if the theoretical problems can be solved (Johnson, 1993; DSrre, 1993) severe practical problems might surface, if the constraints are as complex as the ones proposed here.</Paragraph>
      <Paragraph position="2"> As an alternative we have implemented chart-based parsers using the 'non-interleaved pruning' strategy (terminology from (Maxwell III and Kaplan, 1994)).</Paragraph>
      <Paragraph position="3">  Using this strategy the parser first builds a parse-forest for a sentence on the basis of the context-free backbone of the grammar. In a second processing phase parses are recovered on the basis of the parse forest and the corresponding constraints are applied. This may be advantageous if the context-free backbone of the grammar is 'informative' enough to filter many unsuccessful partial derivations that the parser otherwise would have to check.</Paragraph>
      <Paragraph position="4"> As clearly a CUG grammar does not contain such an informative context-free backbone a further step is to use 'selective feature movement' (cf. again (Maxwell III and Kaplan, 1994)). In this approach the base grammar is compiled into an equivalent modified grammar in which certain constraints from the base grammar are converted to a more complex context-free backbone in the modified grammar.</Paragraph>
      <Paragraph position="5"> Again, this technique does not easily give good results for grammars of the type described. It is not clear at all where we should begin extracting appropriate features for such a modified grammar, because most information passing is simply too 'indirect' to be easily compiled into a context-free backbone.</Paragraph>
      <Paragraph position="6"> We achieved the best results by using a 'handfabricated' context-free grammar as the first phase of parsing. This context-free grammar builds a parse forest that is then used by the 'real' grammar to obtain appropriate representation(s) for the input sentence. This turned out to reduce parsing times considerably.</Paragraph>
      <Paragraph position="7"> Clearly such a strategy raises questions on the relation between this context-free grammar and the CUG grammar. The context-free grammar is required to produce a superset of the derivations allowed by the CUG. Given the problems mentioned above it is difficult to show that this is indeed the case (if it were easy, then it probably would also be easy to obtain such a context-free grammar automatically).</Paragraph>
      <Paragraph position="8"> The strategy can be described in somewhat more detail as follows. The context-free phase of processing builds a number of items defining the parse forest, in a format that can be used by the second processing phase.</Paragraph>
      <Paragraph position="9"> Such items are four-tuples (R, Po,P,n) where R is a rule name (consistent with the rule names from the CUG), P0, P are string positions and D describes the string positions associated with each daughter of the rule (indicating which part of the string is covered by that daughter).</Paragraph>
      <Paragraph position="10"> Through a head-driven recursive descent the second processing phase recovers derivations on the basis of these items. Note that the delayed evaluation technique for complex constraints is essential here. Alternative solutions are obtained by backtracking. If the first phase has done a good job in pruning many failing search branches then this is not too expensive, and we do not have to worry about the interaction of caching and complex constraints.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>