<?xml version="1.0" standalone="yes"?>
<Paper uid="C88-2121">
  <Title>Example,~ of Adjuncts: S vp A A S VP PP S S A A A S ADV P NP$ SC S~</Title>
  <Section position="2" start_page="0" end_page="0" type="metho">
    <SectionTitle>
1 'Lexicalization' of grammar for-
</SectionTitle>
    <Paragraph position="0"> malisms Most of the current linguistics theories tend to give lexical accounts of several phenomena that used to be considered purely syntactic. The information put in the lexicon is therefore increased and complexified (e.g. lexical rules in LFG, used also by HPSG, or Gross 1984's lexicongrammar). But the question of what it means to 'lexicalize' a grammar is seldom addressed. The possible consequences of this question for parsing are not fully investigated. We present how to 'lexicalize' grammars such as CFGs in a radical way, while possibly keeping the rules in their full generality. If one assumes that the input sentence is finite and that it cannot be syntactically infinitely ambiguous, the 'lexicalization' simplifies the task of a parser. We say that a grammar formalism is 'lexicalized' if it consists of: * a finite set of structures to be associated with lexical items, which usually will be heads of these structures, * an operation or operations for composing the structures. 1 The finite set of structures define the domain of locality over which constraints are specified and these are local with respect to their lexical heads.</Paragraph>
    <Paragraph position="1"> Not every grammar formalism in a given form is in a 'lexicalized' form. For example, a CFG, in general, will not be in a 'lexicalized' form. However, by extending its domain of locality, it can be 'lexicalized'. We require that the 'lexicalized' grammar produces not only the same language as the original grammar, but also the same structures (or tree set)? We propose to study the conditions under which such a 'lexicalization' is possible for CFGs and TAGs. The domain of locality of a CFG can be extended by using a tree rewriting system that only uses substitution. We state the conditions under which CFGs can be 'lexlcalized' without changing the structures originally produced. We argue that even if one extends the domain of locality of CFGs to trees, using only substitution does not give the freedom to choose the head of each structure. We then 1 By 'lexicalization' we mean tlmt in each structure there is a lexical item that is realized. We do not mean just adding features (such as head) and unification equations to the rules of the formalism. Categorlal grammars are 'lexicaUzed' according to our definition, However, they do not correspond in a simple way to a rtde-based system that could be used for top-down recognition.</Paragraph>
    <Paragraph position="2">  show how adjunction enables one to freely 'lexicalize' a CFG.</Paragraph>
  </Section>
  <Section position="3" start_page="0" end_page="581" type="metho">
    <SectionTitle>
2 'Lexicalization' of CFGs
</SectionTitle>
    <Paragraph position="0"> The domain of locality of CFGs can be easily extended by using a tree rewriting grammar. This tree rewriting grammar consists of a set of trees that are not restricted to be of depth one (as in CFGs). It uses only substitution as a combining operation. Substitution can take place only on non-terminal nodes of the frontier of each tree. The language is defined to be the set of strings on the frontiers of trees whose roots are labeled by a distinguished symbol S. It is easy to see that the set of languages generated by this tree rewriting grammar is exactly the same set as context-free languages.</Paragraph>
    <Paragraph position="1"> If no recarsive chain rules exist, it is formally possible to 'lexicalize' a CFG with this tree rewriting grammar, a Recursive chain rules are disallowed since they introduce unbounded structures with no lexical items attached to them.</Paragraph>
    <Paragraph position="2"> Although a CFG can be 'lexicalized' by using trees, it is not possible to choose freely the lexical item that plays the role of the head for each structure. Consider the following  However, in this 'lexiealization' one is forced to choose adv as the head of the structure given in the first tree. It is not possible to choose the verb v as the head of this structure. If one tried to do so, recursion on the substitution of the VP node would be inhibited.</Paragraph>
    <Paragraph position="3"> 2&amp;quot;his example shows that although it is possible to 'lexicalize' CFGs, substitution alone does not allow us to freely choose the lexical heads. Substitution alone forces us to make choices that might not be syntactically and semantically justified.</Paragraph>
    <Paragraph position="4"> Tree adjoining grammars (TAGs) are also a tree-based system, ltowever, the major composition operation in TAGs is adjoining or adjunction. It builds a new tree from an auxiliary tree # and a tree c~ (a is any tree, initial, auxiliary or derived by adjunction). The resulting tree is called a derived tree. Let t~ be atree containing a node n labeled by X and let # be an auxiliary tree whose root node is also labeled by X. Then the adjunction of fl to a at node n results a tree 7 as shown in Figure 1. Adjunetion enables to factor recursion from local dependencies.</Paragraph>
    <Paragraph position="5"> aNote that a CFG in Greibach normal form can be 'lexicallzed' trivially. But since G~eihach normal form of a given CFG might not generate the same tree set as the original grammar, it cannot be used as a 8.eneral method for 'lexicaUzation'.</Paragraph>
    <Paragraph position="6">  The previous CFG can be 'lexicalized' by using adjunction as follows: 4</Paragraph>
    <Paragraph position="8"> The auxiliary tree rooted by VP can be inserted in the S tree on tile VP node by adjunction. Using adjunction one is thus able to choose the appropriate lexical item as head. This example illustrates the fact that a CFG with no recursive chain rules can be 'lexicalized' in TAGs, and that if that is done the head can be freely chosen.</Paragraph>
    <Paragraph position="9"> 3 TAGs and 'lexicalization' TAGs are 'naturally' lexicalized because they used an extended domain of locality. TAGs were first introduced by Joshi, Levy and Takabashi (1975) and Joshi (1985).</Paragraph>
    <Paragraph position="10"> For more details on the original definition of TAGs, we refer the reader to Joshi (1985), Kroch and Joshi (1985) or Vijay-Shanker (1987). It is known that Tree Adjoining Languages (TALs) are mildly context-sensitive. TALs properly contain context-free languages. It is also possible to encode a context-free grammar with auxiliary trees using adjunction only. However, although the languages correspond, the possible encoding does not directly reflect the original context-free grammar since this encoding uses adjunction.</Paragraph>
    <Paragraph position="11"> Although adjunction is more powerful than substitution and could be used to simulate it, in recent linguistic work in TAG (Abeill~ 1988) substitution has been used in addition to adjunction in order to obtain appropriate structural descriptions in certain cases, such as verbs taking two sentential arguments (e.g. &amp;quot;John equates solving this problem with doing the impossible&amp;quot;). Adding substitution does not change the mathematical properties of TAGs.</Paragraph>
    <Paragraph position="12"> We describe very briefly the Tree Adjoining Grammar formalism with adjunction and substitution.</Paragraph>
    <Paragraph position="13"> A Tree Adjoining Grammar is a tree-based system that consists of.three finite sets of trees: I, A and L. The trees in I O A tJ L are called elementary trees.</Paragraph>
    <Paragraph position="14"> The trees in I are called initial trees. Initial trees represent basic sententiai structures. They are usually considered as projections of the verb and they take nominal  complements. Initial trees (see the left tree in Figure 2) are rooted in S and their frontier consists of terminal symbols (including the empty string) and non-terminal nodes to be substituted for.</Paragraph>
    <Paragraph position="15"> The trees in A are called auxiliary trees. They can represent constituents which ar e adjuncts to basic structures (adverbial). They can also represent basic sentential structures corresponding to verbs or predicates taking sentential complements. Auxiliary trees (see right tree in Figure 2) are characterized as follows: * internal nodes are labeled by non-terminals; * leaf nodes are labeled by terminals or by non-terminal nodes to be substituted except for exactly one node (called the foot node) labeled by a non-terminal on which only adjunction can apply; furthermore the label of the foot node is the same as the label of the root node.</Paragraph>
    <Paragraph position="17"> The trees in L are called lexical trees. They represent basic categories or constituents which serve as arguments, to initial or auxiliary trees. They are reduced to a pre-terminal node in the case of simple categories or are expanded into tree structures in the case 0f compounds.</Paragraph>
    <Paragraph position="18"> Structurally they are characterized the same way as initial trees except that they are not necessary rooted by S.</Paragraph>
    <Paragraph position="19"> As noted in Section 2, the major composition operation in TAGs is adjunction.</Paragraph>
    <Paragraph position="20"> We define substitution in TAGs to take place on specified nodes on the frontiers of elementary trees. When a node is marked to be substituted, no adjunction can take place on that node. Furthermore , substitution is always mandatory. In case of substitution on a node labeled by S (sentential complement), only trees derived from initial trees (therefore rooted by S) can be substituted. In all other cases, any tree derived from a lexlcal tree rooted by the same label as the given node can be substituted.</Paragraph>
    <Paragraph position="21"> The resulting tree is obtained by replacing the node by the derived tree. Substitution is illustrated in Figure 3.</Paragraph>
    <Paragraph position="22"> We conventionally mark substitution nodes by a down arrow (~).</Paragraph>
    <Paragraph position="23"> We define the tree set of a TAG G, T(G) to be the set of all derived trees starting from initial trees in I. Furthermore, the string language generated by a TAG, PS:(G), is defined to be the set of all terminal strings of the trees in T(G).</Paragraph>
    <Paragraph position="24"> Grammar rules defined by the linguistic theory are not the same as the rules used by the parser--let us refer to them as parser rules. A parser rule is defined to be a structure encoding a rule of the grammar (or a set of rules) instantiated bythe parser when it comes to alex- null ical item (considered to 'yield' the rule(s)). It is thus a unique object. It is individualized by the lexical item, which is itself individualized by its position in the input string. The lexical item is directly inserted into the structure corresponding to the parser rule, and such a rule can only occur once. Lexleal items are differentiated by their realization in the input sentence and also their position in the sentence. Therefore a given rule corresponds to exactly one lexical item in the input sentence.</Paragraph>
    <Paragraph position="25"> The structures are produced by lexical items which serve as heads. If a structure has only one terminal, the terminal is the head of the structure; if there are several terminals, the choice of the head is linguistically motivated, e.g. by the principles of X theory. S also has to be considered as the projection of a lexical head, usually V. Each lexical item corresponds to as many entries as there are possible category or argument structures.</Paragraph>
    <Paragraph position="26"> The category structure is a lexical tree that is not necessarily reduced to a single category. It corresponds to the maximal projection of a category in the case of simple phrases, to the entire compound, in the case of compound categories.</Paragraph>
    <Paragraph position="27"> Category structures can be of two different kinds: * lexical trees reduced to a single category: ~  The argument structure is not reduced to a list of arguments as the usual subcategorization frames. It is the syntactic structure constructed with the lexlcal value of the predicate and with all the nodes for its arguments. The argument structure for a predicate is its maximal structure. An argument is present in the argumefit structure even if it is optional and its optionality is stated in the structure.</Paragraph>
    <Paragraph position="28"> SThe index in &amp;quot;parentheses on a lexical item that produces the structure encodes the position of the lexical item in the string. A simple case of a argument structure is a verb with its subcategorized arguments. For example, the verb saw (at position i) generates the following structures (among others): 6</Paragraph>
    <Paragraph position="30"> The left structure corresponds to: 0 Jolt. 1 aaw 2 llary a (i= 2) and the other to: 0 John 1 saw 2 that 3 Mary 4 left 5. (i----2) An argument structure can correspond to either one or a set of syntactic surface structures. The lexical head will then produce a set of possible trees, one for NP0 saw NP1 and another for whol did NP 0 see e i ?, for example. If one defines principles for building such sets of trees, these principles will correspond to syntactic rules in a derivation-based theory of grammar.</Paragraph>
    <Paragraph position="31"> Category and argument structures thus instantiated as the parser scans the input string are combined together in a sentence t~tructure by adjoining or substituting.</Paragraph>
    <Paragraph position="32"> As Gross (1984), we consider verbs, nouns, and adjectives as predicates yielding sentences. They can take nominal or sentential arguments. If the predicate takes nominal arguments it produces an initial tree. If it takes a sentential argument then it produces an auxiliary tree. Putting arguments into predicates is done by substituting nominal arguments or by adjoining a predicate structure to its sentential argument.</Paragraph>
    <Paragraph position="33"> Adjuncts are represented as auxiliary trees rooted by the category of the node they are adjoined to. They are also produced by a head. They can be reduced to a basic category or take nominal or sentential arguments introduced by substitution.</Paragraph>
    <Paragraph position="34">  If we have a 'lexicalized' grammar, the grammar of the parser can be reduced to a set of structures whose nature depends on the input string and whose size is proportional to the length of the sentence (if we suppose that the number of structures associated with a lexical item is finite). Since each structure' ('rule') corresponds to a token in the degWe put indices on categories to express syntactic roles (0 for subject, 1 for object).</Paragraph>
    <Paragraph position="35"> sentence, it can be used only once. Rules are now differentiated by their realization in the sentence. The number of rules that can be used for a given sentence is bounded and is proportional to the length of the sentence. Since each rule can be used once, recursion does not lead to the usual non-termination problem. Once a structure has been cho~ sen for a given token, the other possible structures for the same token do not participate in the parse. Of course, if the sentence is ambiguous, there may be more than one choice.</Paragraph>
    <Paragraph position="36"> If one adopts an off-line parsing algorithm, the parsing problem is reduced to the following two steps: t First produce the set of structures corresponding to each word in the sentence. This step performs the role of an expanded morphological analysis (or tagging).</Paragraph>
    <Paragraph position="37"> (r) Then put the argument structures into the predicate structures. This step performs a modified syntactic analysis.</Paragraph>
    <Paragraph position="38"> In principle any parsing strategy can be applied to execute the second step, since the number of structures produced js finite and since each of them corresponds to a token in the input string, the search space is finite and termination is guaranteed. In principle, one can proceed inside out, left to right or in any other way. Of course, standard parsing algorithm can be used too. In particular, we can use the top-down parsing strategy without encountering the usual problems due to recursion. Problems in the prediction step of the Earley parser used for unification-based formalisms no longer exist. The use of restrictors as proposed by Shieber (1985) is no longer necessary and the difficulties caused by treating subcategorization as a feature is no longer a problem.</Paragraph>
    <Paragraph position="39"> By assuming that the number of structures associated with a lexical item is finite, since each structure has a lexical item attached to it, we implicitly make the assumption that an input string of finite length cannot be syntactically infinitely ambiguous.</Paragraph>
    <Paragraph position="40"> Since the trees are produced by the input string, the parser can use information that might be non-local to guide the search. For example, consider the language generated by the following CFG (example due to Mitch Mar- null This grammar generates the language:{a*x} U {a'y}.</Paragraph>
    <Paragraph position="41"> In a standard CFG parsing algorithm, A's and B's will be built until the last token in the input (x or y) is recognized. It would require unbounded look-ahead to decide which rule (3 -+ A or S ~ B) to choose. One can encode the grammar in TAG as follows:  Suppose that the heads of the initial trees are respectively x and y and that a is the head of both auxiliary  trees. Then, if the elementary trees are built according to the input string, and if a top-down strategy is used, only A or B trees will be built.</Paragraph>
    <Paragraph position="42"> An application concerns the parsing of discontinuous constituents. They are recognized even if there are unbounded insertions between their components and even if their 'head' is the last element of the string.</Paragraph>
    <Paragraph position="43"> In the two-step strategy described here, before the first step is taken, there is no grammar. After the first step, we have a grammar whose size is proportional to the length of the input string. The size of the grammar to be taken into consideration in the analysis of the parsing complexity of grammar formalisms has been reduced to an amount proportional to the length of the input. Although we have not yet investigated the implication of this approach on some complexity results, we feel that some of them might be improved.</Paragraph>
    <Paragraph position="44"> It is possible to express the parsing problem in a decidable deduction system on trees (similar to Lambek's deduction system on categories (1958 and 1961)). The grammar can be thought as a five-tuple (VN, ~, O, S, Lex) where:  to finite subsets of O: P?' --+ 2(r)(finite).</Paragraph>
    <Paragraph position="45"> A sequent is defined to be of the form: Vl,.. -, rn ~ A, where ri E O and A E VN Two inference rules combine two trees of the left hand side to form a new one. One inference rule corresponds to adjunction of two trees, and the other to substitution of a node in one tree by the other tree. Once two trees are combined, they are replaced by the resulting tree in the left hand side of the seouent. This facts takes into account that each tree corresponds to a single lexical item in the input string. Therefore each tree can be used only once. Axioms of the system are of the form: v ---+ A where r is a completed tree rooted by A.</Paragraph>
    <Paragraph position="46"> The sequent T1,&amp;quot; * &amp;quot;,Tn &amp;quot;----+ A is said to be provable if the sequent can be reduced (by the inference rules) to an axiom; we write: ~- rl,...,r, --+ A.</Paragraph>
    <Paragraph position="47"> Since there are finitely many ways to combine a finite number of trees with each other, the system is decidable. The language generated by such system is defined to be: = {ai,'.. ,anl3rl e Lex(al) s. t. ~- rl,'&amp;quot;,rn ----+ S} Also, one can state a necessary condition on the correctness of a sentence similar to the category count theorem of van Benthem (1985 and 1986).</Paragraph>
  </Section>
  <Section position="4" start_page="581" end_page="582" type="metho">
    <SectionTitle>
5 Extending the Earley-type
</SectionTitle>
    <Paragraph position="0"> parser for TAGs An Earley-type parser for TAGs has been proposed by Schabes and Joshi (1988a). It takes as input a TAG and a sentence to be parsed. It places no restrictions on the grammar. The algorithm is a bottom-up parser that uses top-down filtering. It is able to parse constraints on adjunction, substitution and feature structures for TAGs as defined by Vijay-Shanker (1987) and Vijay-Shanker and Joshi (1988). It is able to parse directly CFGs and TAGs. Thus it embeds the essential aspects of PATR-II as defined by Shieber (1984 and 1986). Its correctness was proven in Sehabes and Joshi (1988b). The concepts of dotted rule and states have been extended to TAG trees. The algorithm as described by Schabes and Joshi (1988a) manipulates states of the form: s = \[a, dot, side, pos, l, fl, fi, star, t\[, b\[, snbst?\] where a is a tree, dot is the address of the dot in the tree, side is the side of the symbol the dot is on (left or right), pos is the position of the dot (above or below), star is an address in a and l, f~, fr, star, t~, b~ are indices of positions in the input string. The variable subst? is a boolean that indicates whether the tree has been predicted for substitution. null The algorithm uses nine processes: * The Scanner allows lexical items to be recognized.</Paragraph>
    <Paragraph position="1"> * Move dot down and Move dot up perform a tree traversal that allow the parser to scan the input from left to right.</Paragraph>
    <Paragraph position="2"> * The Left Predictor predicts an adjunetion if it is possible.</Paragraph>
    <Paragraph position="3"> * Suppose that the auxiliary tree that we left-predicted has been recognized as far as its foot, then the Left Completor tries to recognize what was pushed under the foot.</Paragraph>
    <Paragraph position="4"> * Once the subtree pushed under the foot has been recognized, the Right Predictor tries to recognize the other half of the auxiliary tree.</Paragraph>
    <Paragraph position="5"> * If the auxiliary tree has been totally recognized, the Right Completor tries to recognize the rest of the tree in which the auxiliary tree has been adjoined.</Paragraph>
    <Paragraph position="6"> * The Substitution Predictor performs the same operations as Earley's original predictor. It predicts for substitution (when appropriate) all lexical trees or initial trees that could be substituted.</Paragraph>
    <Paragraph position="7"> * If the tree that we predicted for substitution has been totally recognized, the Substitution Completor tries to recognize the rest of the tree in which we predicted a substitution.</Paragraph>
    <Paragraph position="8"> The Earley-type parser can be extended to take advantage of the lexicon-based strategy proposed earlier. Once the input string has been scanned and the corresponding elementary trees have been built, the parser will proceed bottom-up using the top-down filtering from the initial trees that have been built. In order to take into account that each tree is unique and therefore can be used only once, a new component r is added to the states. A state is now defined to be: s = \[a, dot, side, pos, l, fl, fr, star, t~, b~, subst?, r\] r encodes the trees corresponding to the input string that have not yet been used: r ~--- {{&amp;quot;/11, &amp;quot;&amp;quot;&amp;quot; ,'~'lk},&amp;quot;&amp;quot; :, {'~ml,&amp;quot;&amp;quot;&amp;quot; ,'~mk}} where {7il,'&amp;quot;,7~j} is the set of trees generated by the lexical item a~.</Paragraph>
    <Paragraph position="9">  The left predictor must be modified so that it predicts only trees that are in the set F of the given state. As soon as one tree (say 7in) is used, the entire set of trees corresponding to the same token ({711,&amp;quot;',7ij}) cannot be used later on. Of course, all competitive paths are taken in parallel as in the usual Earley parser. The way that F is modified by the Left Predictor is illustrated in the following figure: A addedtoSi r=((~ ,...a } ..... {~ ..... ~ ), ..., (v ..... v 1} r=({~ ,...,~ } ........ (~ ..... r }1 n lr il is ml mt 11 lr ml rat  The tree 71u is predicted and therefore the trees corresponding to the token ai ({'Y/l,-'&amp;quot;, &amp;quot;/is}) are removed from</Paragraph>
  </Section>
  <Section position="5" start_page="582" end_page="582" type="metho">
    <SectionTitle>
1 a&amp;quot;
</SectionTitle>
    <Paragraph position="0"> The scanner must also be slightly modified since the head of the structure is differentiated not only by its lexical value but al,'~o by its position in the string.</Paragraph>
  </Section>
class="xml-element"></Paper>