<?xml version="1.0" standalone="yes"?>
<Paper uid="P03-2003">
  <Title>On the Applicability of Global Index Grammars</Title>
  <Section position="3" start_page="0" end_page="0" type="metho">
    <SectionTitle>
2 Global Index Grammars
</SectionTitle>
    <Paragraph position="0"/>
    <Section position="1" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.1 Linear Indexed Grammars
</SectionTitle>
      <Paragraph position="0"> Indexed grammars, (IGs) (Aho, 1968), and Linear Index Grammars, (LIGs;LILs) (Gazdar, 1988), have the capability to associate stacks of indices with symbols in the grammar rules. IGs are not semilinear. LIGs are Indexed Grammars with an additional constraint in the form of the productions: the stack of indices can be &amp;quot;trans4For the notion of dependent paths see for instance (Vijay-Shanker et al., 1987) or (Joshi, 2000).</Paragraph>
      <Paragraph position="1"> mitted&amp;quot; only to one non-terminal. As a consequence they are semilinear and belong to the class of MCSGs. The class of LILs contains L4 but not L5 (see above).</Paragraph>
      <Paragraph position="2"> A Linear Indexed Grammar is a 5-tuple (V;T;I;P;S), where V is the set of variables, T the set of terminals, I the set of indices, S in V is the start symbol, and P is a finite set of productions of the form, where A;B 2 V, fi; 2 (V [T)/, i 2 I:  a. A[::] ! fi B[::] b. A[i::] ! fi B[::] c. A[::] ! fiB[i::]</Paragraph>
      <Paragraph position="4"/>
    </Section>
    <Section position="2" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.2 Global Indexed Grammars
</SectionTitle>
      <Paragraph position="0"> GIGs use the stack of indices as a global control structure. This formalism provides a global but restricted context that can be updated at any local point in the derivation. GIGs are a kind of regulated rewriting mechanisms (Dassow and PVaun, 1989) with global context and history of the derivation (or ordered derivation) as the main characteristics of its regulating device.</Paragraph>
      <Paragraph position="1"> The introduction of indices in the derivation is restricted to rules that have terminals in the right-hand side. An additional constraint that is imposed on GIGs is strict leftmost derivation whenever indices are introduced or removed by the derivation.</Paragraph>
      <Paragraph position="2"> Definition 1 A GIG is a 6-tuple G = (N;T;I;S;#;P) where N;T;I are finite pair-wise disjoint sets and 1) N are non-terminals 2) T are terminals 3) I a set of stack indices 4) S 2 N is the start symbol 5) # is the start stack symbol (not in I,N,T) and 6) P is a finite set of productions, having the following form,5 where 5The notation in the rules makes explicit that operation on the stack is associated to the production and neither to terminals nor to non-terminals. It also makes explicit that the operations are associated to the computation of a Dyck language (using such notation as used in e.g. (Harrison, 1978)). In another notation: a.1  [y::]A ! [y::]fi, a.2 [y::]A ! [y::]fi, b. [::]A ! [x::]a fl and c. [x::]A ! [::]fi x 2 I, y 2fI[#g, A 2 N, fi;fl 2 (N[T)/ and a 2 T.</Paragraph>
      <Paragraph position="3"> a.i A !+ fi (epsilon) a.ii A ! [y] fi (epsilon with constraints) b. A !x a fl (push) c. A !-x fi a fl (pop)  Note the difference between push (type b) and pop rules (type c): push rules require the right-hand side of the rule to contain a terminal in the first position. Pop rules do not require a terminal at all. That constraint on push rules is a crucial property of GIGs. Derivations in a GIG are similar to those in a CFG except that it is possible to modify a string of indices. We define the derives relation ) on sentential forms, which are strings in I/#(N[T)/ as follows. Let fl and be in (N [T)/, - be in I/, x in I, w be in T/ and Xi in (N [T).</Paragraph>
      <Paragraph position="4">  1. If A !,, X1:::Xn is a production of type (a.) (i.e. ,, = + or ,, = [x], x 2 I) then: i. -#flA ),, -#flX1:::Xn ii. x-#flA ),, x-#flX1:::Xn 2. If A !,, aX1:::Xn is a production of type (b.) or push: ,, = x;x 2 I, then: -#wA ),, x-#waX1:::Xn 3. If A !,, X1:::Xn is a production of type (c.) or pop : ,, = -x;x 2 I, then:</Paragraph>
      <Paragraph position="6"> The reflexive and transitive closure of ) is denoted, as usual by /). We define the language of a GIG, G, L(G) to be: fwj#S /) #w and w is in T/g The main difference between, IGs, LIGs and GIGs, corresponds to the interpretation of the derives relation relative to the behavior of the stack of indices. In IGs the stacks of indices are distributed over the non-terminals of the right-hand side of the rule. In LIGs, indices are associated with only one non-terminal at right-hand side of the rule. This produces the effect that there is only one stack affected at each derivation step, with the consequence of the semilinearity property of LILs. GIGs share this uniqueness of the stack with LIGs: there is only one stack to be considered. Unlike LIGs and IGs the stack of indices is independent of non-terminals in the GIG case. GIGs can have rules where the right-hand side of the rule is composed only of terminals and affect the stack of indices. Indeed push rules (type b) are constrained to start the right-hand side with a terminal as specified in (6.b) in the GIG definition. The derives definition requires a leftmost derivation for those rules ( push and pop rules) that affect the stack of indices. The constraint imposed on the push productions can be seen as constraining the context sensitive dependencies to the introduction of lexical information. This constraint prevents GIGs from being equivalent to a Turing Machine as is shown in (Casta~no, 2003c).</Paragraph>
      <Paragraph position="7">  The following example shows that GILs contain a language not contained in LILs, nor in the family of MCSLs. This language is relevant for modeling coordination in NL.</Paragraph>
      <Paragraph position="9"> The next example shows the MIX (or Bach) language. (Gazdar, 1988) conjectured the MIX language is not an IL. GILs are semilinear, (Casta~no, 2003c) therefore ILs and GILs could be incomparable under set inclusion.</Paragraph>
      <Paragraph position="10"> Example 3 (MIX language) .L(Gmix) = fwjw 2fa;b;cg/ and jajw = jbjw = jcjw , 1g</Paragraph>
      <Paragraph position="12"> The following example shows that the family of GILs contains languages which do not belong to the MCSL family.</Paragraph>
      <Paragraph position="14"> The derivation of the string aabbccbbcc shows five dependencies.</Paragraph>
      <Paragraph position="16"/>
    </Section>
    <Section position="3" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.3 GILs Recognition
</SectionTitle>
      <Paragraph position="0"> TherecognitionalgorithmforGILswepresented in (Casta~no, 2003) is an extension of Earley's algorithm (cf. (Earley, 1970)) for CFLs. It has to be modified to perform the computations of the stack of indices in a GIG. In (Casta~no, 2003) a graph-structured stack (Tomita, 1987) was used to efficiently represent ambiguous index operations in a GIG stack. Earley items are modified adding three parameters -;c;o: [-;c;o;A ! fi+Afl;i;j] The first two represent a pointer to an active node in the graph-structured stack ( - 2 I and c * n). The third parameter (o * n) is used to record the ordering of the rules affecting the stack.</Paragraph>
      <Paragraph position="1"> The O(n6) time-complexity of this algorithm reported in (Casta~no, 2003) can be easily verified. The complete operation is typically the costly one in an Earley type algorithm. It can be verified that there are at most n6 instances of  theindices(c1;c2;o;i;k;j)involvedinthisoperation. The counter parameters c1 and c2, might be state bound, even for grammars with ambiguous indexing. In such cases the time complexity would be determined by the CFG backbone properties. The computation of the operations on the graph-structured stack of indices are performed at a constant time where the constant is determined by the size of the index vocabulary.</Paragraph>
      <Paragraph position="2"> O(n6)istheworstcase; O(n3)holdsforgrammars with state-bound indexing (which includes unambiguous indexing)6; O(n2) holds for unambiguous context free back-bone grammars with state-bound indexing and O(n) for boundedstate7 context free back-bone grammars with state-bound indexing.</Paragraph>
    </Section>
  </Section>
  <Section position="4" start_page="0" end_page="0" type="metho">
    <SectionTitle>
3 GIGs and structural description
</SectionTitle>
    <Paragraph position="0"> (Gazdar, 1988) introduces Linear Indexed Grammars and discusses its applicability to Natural Language problems. This discussion is addressed not in terms of weak generative capacity but in terms of strong-generative capacity.</Paragraph>
    <Paragraph position="1"> Similar approaches are also presented in (Vijay-Shanker et al., 1987) and (Joshi, 2000) (see (Miller, 1999) concerning weak and strong generative capacity). In this section we review some oftheabstract configurations thatare arguedfor in (Gazdar, 1988).</Paragraph>
    <Section position="1" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
3.1 The palindrome language
</SectionTitle>
      <Paragraph position="0"> CFGs can recognize the language fwwRjw 2 S/g but they cannot generate the structural description depicted in figure 1 (we follow Gazdar's notation: the leftmost element within the brackets corresponds to the top of the stack):  tion for the language wwR (Gazdar, 1988) Gazdar suggests that such configuration would be necessary to represent Scandinavian  state set is bounded by a constant.</Paragraph>
      <Paragraph position="1"> unbounded dependencies.Such an structure can be obtained using a GIG (and of course a LIG). But the mirror image of that structure cannot be generated by a GIG because it would require to allow push productions with a non terminal in the first position of the right-hand side. However the English adjective constructions that Gazdar argues that can motivate the LIG derivation, can be obtained with the following GIG productions as shown in figure 2.  It should be noted that the operations on indices follow the reverse order as in the LIG case. On the other hand, it can be noticed also that the introduction of indices is dependent on the presence of lexical information and its transmission is not carried through a top-down spine, as in the LIG or TAG cases. The arrows show the leftmost derivation order that is required by the operations on the stack.</Paragraph>
    </Section>
    <Section position="2" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
3.2 The Copy Language
</SectionTitle>
      <Paragraph position="0"> Gazdar presents two possible LIG structural descriptions for the copy language. Similar structural descriptions can be obtained using GIGs.</Paragraph>
      <Paragraph position="1"> However he argues that another tree structure could be more appropriate for some Natural Language phenomenon that might be modeled with a copy language. Such structure cannot be generated by a LIG, and can by an IG (see (Casta~no, 2003b) for a complete discussion and comparasion of GIG and LIG generated trees).</Paragraph>
      <Paragraph position="2"> GIGs cannot produce this structural description, but they can generate the one presented in figure 3, where the arrows depict the leftmost derivation order. GIGs can also produce similar structural descriptions for the language of multiple copies (the language fww+j w 2 S/g as shown in figure 4, corresponding to the grammar shown in example 2.</Paragraph>
      <Paragraph position="4"> We showed in the last section how GIGs can produce structural descriptions similar to those of LIGs, and others which are beyond LIGs and TAGs descriptive power. Those structural descriptions corresponding to figure 1 were correlated to the use of the SLASH feature in GPSGs and HPSGs. In this section we will show how the structural description power of GIGs, is not only able to capture those phenomena but also additional structural descriptions, compatible with those generated by HPSGs. This follows from the ability of GIGs to capture dependencies through different paths in the derivation. There has been some work compiling HPSGs into TAGs (cf. (Kasper et al., 1995), (Becker and Lopez, 2000)). One of the motivations was the potential to improve the processing efficiency of HPSG, performing HPSG derivations at compile time. Such compilation process allowed to identify significant parts of HPSG grammars that were mildly context-sensitive.</Paragraph>
      <Paragraph position="5"> We will introduce informally some slight modifications to the operations on the stacks performed by a GIG. We will allow the productions of a GIG to be annotated with finite strings in I [ -I instead of single symbols. This does not change the power of the formalism. It is a standard change in PDAs (cf. (Harrison, 1978)) to allow to push/pop several symbols from the stack. Also the symbols will be interpreted relative to the elements in the top of the stack (as a Dyck set). Therefore different derivations might be produced using the same production according to what are the topmost elements of the stack. This is exemplified with the productions X !-nv x and X ! [n]v x, in particular in the first three cases where different actions are taken (the actions are explained in the parenthesis) : nn-#wXfl )-nv vn-#wxfl (pop n and push v) n-v-#wXfl )-nv -#wxfl (pop n and -v) vn-#wXfl )-nv v-nvn-#wxfl (push -n and v) n-#wXfl ) [n]v vn-#wxfl ( check and push) We exemplify how GIGs can generate similar structural descriptions as HPSGs do, in a very oversimplified and abstract way. We will ignore many details and try give an rough idea on how the transmission of features can be carried out from the lexical items by the GIG stack, obtaining very similar structural descriptions. Head-Subj-Schema Figure 5 depicts the tree structure corresponding to the Head-Subject Schema in HPSG (Pollard and Sag, 1994).</Paragraph>
      <Paragraph position="6">  scription corresponding to the GIG productions and derivation shown in the next example (which might correspond to an intransitive verb). The arrows indicate how the transmission of features is encoded in the leftmost derivation order, an how the elements contained in the stack can be correlated to constituents or lexical items (terminal symbols) in a constituent recognition process.</Paragraph>
      <Paragraph position="7">  The following GIG productions generate the structural description corresponding to figure 8, where the initial configuration of the stack is  The productions of example 8 (which use some of the previous examples) generate the structural description represented in figure 9, corresponding to the derivation given in example 8. We show the contents of the stack when each lexical item is introduced in the derivation.  nn#Kim we X XP ) -vn#Kim we know XP ) -vn#Kim we know YP XP ) n-vn#Kim we know Sandy XP ) n-vn#Kim we know Sandy X XP ) -vn#Kim we know Sandy claims XP ) -vn#Kim we know Sandy claims YP XP ) n-vn#Kim we know Sandy claims Dana XP /) #Kim we know Sandy claims Dana hates Finally the last example and figure 10 show how coordination can be encoded.</Paragraph>
    </Section>
  </Section>
  <Section position="5" start_page="0" end_page="0" type="metho">
    <SectionTitle>
5 Conclusions
</SectionTitle>
    <Paragraph position="0"> We presented GIGs and GILs and showed the descriptive power of GIGs is beyond CFGs.</Paragraph>
    <Paragraph position="1"> CFLs are properly included in GILs by definition. We showed also that GIGs include  some languages that are not in the LIL/TAL family. GILs do include those languages that are beyond context free and might be required for NL modelling. The similarity between GIGs and LIGs, suggests that LILs might be included in GILs. We presented a succinct comparison of the structural descriptions that can be generated both by LIGs and GIGs, we have shown that GIGs generate structural descriptions for the copy language which can not be generated by LIGs. We showed also that this is the case for other languages that can be generated by both LIGs and GIGs. This corresponds to the ability of GIGs to generate dependent paths without copying the stack. We have shown also that those non-local relationships that are usually encoded in HPSGs as feature transmission, can be encoded in GIGs using its stack, exploiting the ability of Global stacks to encode dependencies through dependent paths and not only through a spine.</Paragraph>
  </Section>
class="xml-element"></Paper>