This action might not be possible to undo. Are you sure you want to continue?

A Dissertation

Presented to The Faculty of the Graduate School of Arts and Sciences Brandeis University Department of Computer Science James Pustejovsky, Advisor

In Partial Fulﬁllment of the Requirements for the Degree Doctor of Philosophy

by Jos´ M. Casta˜o e n February, 2004

The signed version of this dissertation page is on ﬁle at the Graduate School of Arts and Sciences at Brandeis University. This dissertation, directed and approved by Jos´ M. Casta˜o’s committee, has been accepted and e n approved by the Graduate Faculty of Brandeis University in partial fulﬁllment of the requirements for the degree of:

DOCTOR OF PHILOSOPHY

Adam Jaﬀe, Dean of Arts and Sciences

Dissertation Committee: James Pustejovsky, Dept. of Computer Science, Chair. Martin Cohn, Dept. of Computer Science Timothy J. Hickey, Dept. of Computer Science Aravind K. Joshi, University of Pennsylvania

.

c Copyright by Jos´ M. Casta˜o e n 2004 .

.

Debes amar la arcilla que va en tus manos debes amar su arena hasta la locura y si no. que ser´ en vano a S. no lo emprendas. A la Pipi y su gran amor. vii . Rodr´ ıguez.Al Campris y su eterna perserverancia.

.

my American friend. Anna ıa n u Rumshisky. It is my belief that every intellectual work is fruit of a community. in many diﬀerent ways. some I don’t know. ı I cannot express how grateful I am to my compa˜era Daniela in this and every route. This work was inﬂuenced by many people. Ricardo e Rodr´ ıguez. I am extremely grateful to Aravind Joshi for being part of my committee and for his precise comments and suggestions. ix . far away from my initial interests when I arrived at Brandeis. Many thanks to my Argentinian friends and colleagues. Edward Stabler and Stuart Shieber helped me to ﬁnd a way at the initial stages of this endeavour. Mar´ Pi˜ango. I would like to express my gratitude to James Pustejovsky who supported and encouraged me during these years. I would like to thank Martin Cohn for introducing me to Formal Languages and having always time for me. My sincere thanks to Tim Hickey and Ray Jackendoﬀ. Marc Verhagen. Pablo Funes. Francesco Rizzo. Alejandro Renato and the extraordinary friends I met at Brandeis. Ana Arregui. My highest appreciation to those anonymous reviewers who made an eﬀort to understand and comment on my submissions during these years. My family n has a very special dedication. Domingo Medina. First and foremost. Roser Saur´ and Bob Knippen. Aldo Blanco. Piroska Cs´ri. Also many circumstances led me to this unexpected path. Jos´ Alvarez.Acknowledgments Many people contributed to this work.

.

At the same time there is a special concern to preserve the ‘nice’ properties of context-free languages: for instance. Waltham. However there are many problems that cannot be described by context-free languages: “the world is not context-free” [25]. GIls descriptive power is shown both in terms of the set of string languages included in GILs. as well as the structural descriptions generated by the corresponding grammars. Finally. Mildly context-sensitive languages and grammars emerged as a paradigm capable of modeling the requirements of natural languages. as well as an LR-parsing algorithm for the deterministic version of GILs. polynomial parsability and semi-linearity. semi-linearity. Massachusetts by Jos´ M. xi . In order to model coordination. This family of languages preserves the desirable properties mentioned above: bounded polynomial parsability. An Earley type algorithm to solve the recognition problem is discussed in Chapter 5. This thesis presents an abstract family of languages. Innumerable formalisms have been proposed to extend the power of context-free grammars. We present a two-stack automaton model for GILs and a grammar model (Global Index Grammars) in Chapter 2 and 3. One of the hard problems in natural language is coordination. and at the same time has an “extra” context-sensitive descriptive power (e. This work takes these ideas as its goal. Casta˜o e n Context-free grammars (CFGs) is perhaps the best understood and most applicable part of formal language theory. named Global Index Languages (GILs). it might be necessary to deal with the multiple copies language: {ww+ |w ∈ Σ∗ } [29].ABSTRACT Global Index Languages A dissertation presented to the Faculty of the Graduate School of Arts and Sciences of Brandeis University.g the “multiple-copies” language is a GI language). we discuss in Chapter 6 the relevance of Global Index Languages for natural language phenomena. Then characterization and representation theorems as well as closure properties are also presented. One of those problems concerns natural language phenomena. There is increasing consensus that modeling certain natural language problems would require more descriptive power than that allowed by context-free languages.

.

. . . . . . . . . . 4 Global Index Languages Properties 4.3 GILs and Dyck Languages . . . . . . 2.4 Equivalence of GIGs and LR-2PDA . .1 Introduction . . . . . . . . . . . . .1. . . . . . . . . . . . . . 3. . .1. . . . . . . . . . .1 GILs. . . . . . . . . . . . . . . . . . . . . . . . . . Results . . . . . . . . . . . . . . . . . . . . . . . .4 Examples of LR-2PDAs . . . .2 Outline of the Thesis and Description of the . 2. . . . . . . .4 Pumping Lemmas and GILs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1 Automata with two Stacks . . . .4. . . . . .1 trGIGS . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Closure Properties of GILs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4. . . . . . . . . . . . . .1 EPDA and equivalent 2 Stack Machines . . . .1 Natural Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3. . . .Contents vii Acknowledgments Abstract List of Figures 1 Introduction 1. . . . . . . . . . . . . . .2 Left Restricted 2 Stack Push Down Automatas (LR-2PDAs) . . . . . . . . . . .1. . . . . . . . . . .5. . . . . .1 Relations to other families of languages . . . . . . . . . . . . . .3 Semilinearity of GILs and the Constant Growth property 4. . . . . . . . . . . . . .1. . . .2. . . . . . . . . . . . . . . . .2 LR-2PDA with deterministic auxiliary stack . . . . . . . . . . . . . . . . . . . . . . .5. . . . . . 1. . . . . . . . 1. . . . .1 Deterministic LR-2PDA . . . 3.5 Determinism in LR-2PDA . . . . 2. . . . . . . . . . . . . . . .2 Shrinking Two Pushdown Automata . . . 4. . . . . . . . . . 2. . . . . . . . . . . . . 3 Global Index Grammars 3. . . . . . . . . . . . . . 2. . . . . . . .3 Comparison with TM. . . . .2 Global Index Grammars . . . ﬁnite turn CFGs and Ultralinear GILs . . . . . . 1. . . . . . . . . .2 GIGs examples . . . ix xi xv 1 1 2 4 5 6 9 9 10 12 13 15 17 20 20 21 23 23 24 26 28 32 35 41 41 42 44 46 47 2 Two Stack Push Down Automata 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3. . . . . . .2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1. . . . . . . . . . . . . . . . . . .1. . . . . . . .1 Indexed Grammars and Linear Indexed Grammars 3. . . . . . . . . 2. . . . . . . . . . . . . . . . . . . . . . . . . . .2 Biology and the Language of DNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PDA and LR-2PDA . . . . . . . . . . . . . . xiii . 4.3 Our proposal . 2. . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . GILs.3 The Goto Operation. . . . . . . . . . . . . . .1. . . . . . . . . . . . .2 Parsing Schemata . . . . . . . . . . . . .1 LR items and viable preﬁxes . 5. . . . . . . . . . . . . 73 . . 6. . 98 . . . . . . . . . . . . . . . . . . . . . . . . .1 Earley Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . .3 The Copy Language .2 Time and Space Complexity . . . . . . . . . . . . . . . . . . . . .1 Graph-structured Stacks . . . . . . . . . . . . . . .6. . . . . . . . . . . . . . . . . . . . . . . . . 80 . . 5. . . . .2.1. . . . . . . .3. . . . . . . . . . . . . . . . . 99 . . . . 5. . . . . . . . . . . . . . . . . . 53 . . . . . . . . . .1.2 The palindrome language . .3 Parsing Schemata for GIGs . . 6. . . 51 . . . . .4 Earley Algorithm for GIGs: ﬁnal version . 75 . . . . . . . . . .3. .5 Implementation . . . . . . . . 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 . 6. .4. . . . . . . . . . . . . . . . . .4. . 73 . . 81 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 xiv . . .4. .3 GIGs and HPSGs . . .6 LR parsing for GILs . . . . 5. . . . . . . . . . . . . . . . . . . . . . . .1 LIGs in push-Greibach Normal Form . . . . . . . . 79 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 . . 100 . 7 Conclusions and Future Work 125 7. . . . . . . . . . . .1 Overview . . . . . . . . . . . .1 Linear Indexed Grammars (LIGs) and Global Index Grammars (GIGs) 6.4 Proof of the Correctness of the Algorithm . . . . . . . . .1. . .3 Reﬁning the Earley Algorithm for GIGs . . . . .6. . . . . 5. .5 Derivation order and Normal Form . . . . . . . . . . 5. . .2 The Closure Operation. 5. . . . . . . . . . . . . . . . . .1 Future Work . 83 . . . . . . . . . . . . . . . . 5. . .2 Set Inclusion between GIGs and LIGs . . . . . . . . . . . . . .2. . 5. . 61 . .1 Control of the derivation in LIGs and GIGs . . . . .1. . . . . . . .6. . . . . . . . . . . . . . . 6. . . . . . . 5. . . .4. . . . . . . . . . . . . . . . . . . . 48 5 Recognition and Parsing of GILs 5. . . . . . . . 5. . . . . . . . . . . . . 5. . . . . . . . . . . . . . . . . 107 107 108 108 110 112 113 115 116 119 6 Applicability of GIGs 6. . . . . . . . . . . 5. . . . . . . . . 96 . . . . . . . . . . 51 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1 Control Languages . . . . . 98 . . . . . . . .5 Crossing dependencies . . 6. . . . . . . . .4 Multiple dependencies .2. . . . . .3 Complexity Analysis . . . . . . . . . . . . . . . . . . . 6. . .2. . . . . . 5. . . . . . . . . . . . . 6.2 First approach to an Earley Algorithm for 5. . . . . . . . . . . . . . . . . . . 52 . . . . . . . .2 GILs Recognition using Earley Algorithm . . 5. . . . .2. . . . . . . .

. . . . . . 60 Paths and reductions in a graph structured stack with i and ¯ nodes . . . . . . 70 Completer E. . . . . . . . . . . . . . . . . . 59 A complete steps in the graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 Path invariant . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 11 15 15 17 17 18 Two graph-structured stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22 5. . . .5 Language relations . . . . . . . . . . . . . . . . . . . . . . . . 79 GIG invariant . . . 63 i I-edges . . . . . . . . . . . . . . . . 58 i Push and Pop moves on diﬀerent spines . . . . . .1 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A PDA . . . . . . . . . . Dutch Crossed Dependencies (Joshi & Schabes 97) A Turing Machine . . . . . . . . . .4 5. . . . . . . . . . . . . . . . . . . . . . . . . . 58 A predict time graph . . . . . . . . . . .2 2. . . . . . . . . . . . . . . . . . . . . . .5 5. . . . . . . . . . . . . . . . . . . . . . . . . .8 5. . . . . . . . . . . 64 Completer A . . . . . 68 Completer C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16 5. . . . . . . . . . . . . . . . . . . . .3 2. . . . . . . .15 5. . . . . . . . . . . . . . . . . . . . 59 Two alternative graph-structured stacks . . . . 71 Completer F . . . . . . 60 Ambiguity on diﬀerent spines . . . . . . . . . . .21 5. . . . . . . . . . . .3 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 109 109 110 110 xv . 88 Set of States for Gwcw . . . Another non context-free structural description for the language wwR GIG structural descriptions for the language wwR . . . .1 6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5 2. . . Two LIG structural descriptions for the copy language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . last case . . . . . . . . . . . . . .13 5. . . . . . . . . . . . .20 5. . . . . . .7 5. . . 57 A graph structured stack with i and ¯ nodes . . . . . . . . . . . . . . . 73 Earley CFG invariant . . . . . . . . . .List of Figures 1. . . 102 LIGs: multiple spines (left) and GIGs: leftmost derivation . . . . . . . . . . . .4 6. . LR-2PDA . . . . 69 Completer D . . . . . . . . . .3 6. . . 68 Completer B . .24 6. 100 Transition diagram for the PDA recognizing the set of valid preﬁxes. .14 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19 5. .23 5. . 52 Push and Pop moves on the same spine . . . . . . . sLR-2PDA . . . . . . . . . . . . . . . . . . . . . .1 5. . . . . . . . . . .1 2. . . . . . . . . . . . . . . . . . . . . .11 5. . . . . . . . . . . . . . . . . . . . . . . . . . . .6 5. . . . . . . . . . . . . . . . . .6 5. . . . .2 5. . . . . . . . . . . . . . . . . . . . . .18 5. . . . . . . . . . . . . . . . . 60 Two alternative graph-structured stacks distinguished by position . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 2.17 5. . . . . 72 Completer G . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 i A graph structured stack with i and ¯ nodes . . . . . . . . . . . . . . . . . . . . . . . . . . . .12 5. . . . Multiple agreement in an sLR-2PDA . . . . . . . . . . . . . . . . .2 6. .10 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A non context-free structural description for the language wwR . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 5. . . . . . . . annotated with indices for the grammar Gwcw . . . . . . . .

. . . . . . . . . . .16 6. . . . . . . . . GIG structural descriptions of 3 dependencies . . . . . . . . . . . . Head-Comps Schema tree representation . . . . . . . .18 6. . . . . . .13 6. . . . . . . . . . . . .17 6. . . . . . . . . . . . . . . .15 6. LIG and GIG structural descriptions of 4 and 3 dependencies A LIG and a GIG structural descriptions of 3 dependencies . . . . . . . . . . . . . . . . . . . . . . . . . Head-Comp in GIG format . . .7 6. .14 6. . .22 An IG and GIG structural descriptions of the copy language . LIGs not in push-GNF II in GIGs . . . . . . . . . . . . . . . . .20 6. . . . . . . . . . . . . Left and right recursive equivalence in LIGs . . . . A GIG structural description for the multiple copy language . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12 6.10 6. . . . . . . . . . . . . . . . . . . . .19 6. . . . . . . . . . . . . . . second case . Head-Subject in GIG format . . .21 6. . . . . . . . SLASH and coordination in GIG format . . . . . . LIGs not in push-GNF II . . . . . . . . . . . . . . . . . . . . . . 111 111 112 112 113 113 117 117 118 118 119 120 121 121 122 123 124 xvi . . . . . . . . . . . . . . . . . . . . . . .6. . . . .9 6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . LIGs not in push-GNF I . . . . . . Head-Subject Schema . .6 6. . . . . . . . . Left and right recursive equivalence in LIGs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 6. . . . . .11 6. . . . . . . . . . . . GIG structural descriptions of 4 dependencies . . . . . . . . . . . . . . . . . . SLASH in GIG format . .

well understood and most widely applicable part of formal language theory. 1 . closure properties). In [25] seven situations which cannot be described with a context-free framework are given. 59]). The purpose of this thesis is to explore an alternative formalism with restricted context-sensitivity and computational tractability. In an automaton model those extensions either use constrained embedded or additional stacks (cf. Many formalisms have been proposed to extend the power of context-free grammars using control devices. 81. at least.Chapter 1 Introduction 1. We try to obtain a model with eﬃcient computation properties. polynomial parsability. for the following areas: • Natural Language modeling and processing. However there are many problems that cannot be described by context-free languages.1 Introduction Context-free grammars (CFGs) constitute perhaps the most developed. The appeal of this approach is that many of the attractive properties of context-free languages are preserved (e.g. • Computational Biology • Possibly also relevant to programming languages which might use context sensitive features (like Algol 60). where the control device is a context-free grammar (see [87] and [26] regarding control languages). semilinearity property. Such a model is relevant. [7.

among others. Within Mildly-Context Sensitive formalisms we focus on Linear Indexed Grammars (LIGs) and Tree Adjoining Grammars (TAGs) which are weakly equivalent. additional levels of embeddedness. multiple context free grammars [71]. We will focus in natural language problems from a language theoretic point of view. They form hierarchies of levels of languages. 23. scrambling. where a language of level k properly includes a language of level k − 1. Weir’s [87]. or additional stacks can be added.g. We will exemplify this issue with some properties of natural language and we will consider some biology phenomena. As a consequence those generalizations provide more expressive power but at a computational cost. as modeled by {an bm cn dm | n m ≥ 1} Mildly context-sensitive grammars [43] have been proposed as capable of modeling the above mentioned phenomena. and multi-push-down grammars [21]. The complexity of the recognition problem is dependent on the language level. In general. for a level k language the complexity of the recognition problem is a polynomial where the degree of the polynomial is a function of k. 86] and [55.1 Natural Language Regarding natural languages (one of the seven cases mentioned above). Georgian Case and Chinese numbers) might be considered 3 However to be beyond certain mildly context-sensitive formalisms. These constructions are exempliﬁed as [26]:2 – reduplication. [46. in particular related to the so called Mildly-Context Sensitive formalisms. etc.1. .3 It has been claimed that a NL model must have the following properties:4 1 See 2 The for example [73. Examples of those related hierarchies are: Khabbaz’s [49]. following type of languages are also relevant to model molecular biology phenomena [70] there are other phenomena (e. 47] on semi-linearity. that can be modeled with GILs. INTRODUCTION Such models can be generalized and additional control levels. leading to languages of the form {ww |w ∈ Σ∗ } – multiple agreements.2 CHAPTER 1. – crossed agreements. 29]. corresponding to languages of the form {an bn cn | n ≥ 1}. 1. there is increasing consensus1 on the necessity of formalisms more powerful than CFGs to account certain typical natural languages constructions. {an bn cn dn | n ≥ 1}. 4 See for example.

head grammars (HGs). and the time and space complexity of the recognition problem.g. 62]). a stronger version of this requirement ) – Polynomial parsability – Limited cross-serial dependencies – Proper inclusion of context-free languages 3 The most restricted mildly context-sensitive grammar formalisms are linear indexed Grammars (LIGs).. A TAG/LIG is a level-2 control grammar. Many diﬀerent proposals for extending the power of LIGs/TAGs have been presented in the recent past. L = {an bn cn dn |n ≥ 1})... In such hierarchies there is a correlation between the complexity of the formalism (grammar or automata).a2 k | n ≥ 0} and {w2 k −1 |w ∈ Σ∗ } but does not contain the languages n n {a1 . INTRODUCTION – Constant growth property (or semi-linearity.1. tree adjoining grammars (TAGs).. More expressive power can be gained in a mildly context-sensitive model by increasing the progression of this mechanism: in the grammar model adding another level of grammar control. Tree Adjoining languages belong to the class L2 in Weir’s hierarchy. an increase in descriptive power is correlated with an increase in time and space parsing complexity. its descriptive power. They have been proven to have recognition algorithms with time complexity O(n6 ) considering the size of the grammar a constant factor ( [67. The equivalent machine model is a nested or embedded push down automata (NPDA or EPDA). One of the characteristics of mildly context sensitive formalisms is that they can be described by a geometric hierarchy of language classes. Therefore the following relations follow: The family of level-k languages contains the languages n n {a1 . This is reﬂected in the pumping lemma.. These formalisms have long been used to account for natural language phenomena.1.a2 k +1 | n ≥ 0} and {w2 k −1 +1 |w ∈ Σ∗ } . and in the machine model allowing another level of embeddedness in the stack. Their expressive power regarding multiple agreements is limited to 4 counting dependencies (e. A lemma for level k of the hierarchy involves “pumping” 2k positions in the string. and combinatory categorial grammars (CCGs) which are weakly equivalent. where a CFG controls another CFG. However.

Contextual Languages do not properly include context-free languages.1. 66] is another formalism with some mildly context sensitive characteristics. mutation and rearrangements. Direct Repeats (the copy language). 69]). Tree Description Grammars [47] are other such examples. generative grammars have been proposed as models of biological phenomena and the connections between linguistics and biology have been exploited in diﬀerent ways (see [40. For LMGs the complexity of the recognition problem is O(|G|m(+p)n1 +m+2p ) where p is the arity of the predicates. conformation of macromolecules and the computational analysis of sequence data are problems which have been approached from such a perspective. but their complexity and expressive power is bound to some parameter in the grammar (in other words the expressive power is bound to a parameter of the grammar itself).2 Biology and the Language of DNA Recently. Multivalued Linear Indexed Grammars [63]. u ¯ . nor deterministic nor linear. However. He shows that the language of nucleic acids is not regular. In Coupled Context-Free Grammars the recognition problem is in O(|P | · n3l ) where l is the rank of the grammar [28] and Multiple Context Free Grammars is O(ne ) where e is the degree of the grammar. and m the number of terms in the productions. or ordering) the recognition problem is in O(n3 ·2 k −1 ) [86. 38. and the related Literal Movement Grammars (LMGs).4 CHAPTER 1. Those problems which are beyond context free are: Tandem Repeats (multiple copies). Gene regulation. Contextual Grammars [52. 87]. 68] proposes a grammar model to capture the language of DNA. Range Concatenative Grammars [34. 1. Pseudoknots (crossing dependencies) represented as: Lk = {uv¯R v R }. There are other formalisms related to mildly context-sensitive languages that are not characterized by a hierarchy of grammar levels. INTRODUCTION An increase in the language level increases the time (and space) complexity but it still is in P : for a level-k control grammar (or a level-k of stack embeddedness. Some of those formalisms are: Minimalist grammars [78. 12]. 10. gene structure and expression. Searls [70. recombination. that it is ambiguous and that it is not context-free. 54]. In this case the complexity of the recognition problem is a bound polynomial: O(n6 ) space and O(n9 ) time [36].

INTRODUCTION 5 Unbounded number of repeats.ak n | n ≥ 1. (GILs). We will also show that it is able to describe phenomena relevant both to natural language and biology. which is conjectured not to be an Indexed Language.3 Our proposal Unlike mildly context-sensitive grammars and related formalisms. He proposed String Variable Grammars to model the language of DNA. inverted repeats. or interleaved repeats. • L(Gsum ) = { an bm cm dl el f n | n = m + l ≥ 1}. String Variable Languages are a subset of Indexed Languages. and they are able to describe those phenomena. there is no correlation between the descriptive power (regarding the three phenomena we mentioned) and the time complexity of the recognition problem. in the model we present here. k ≥ 2} any number of agreements or dependencies.. however there are many GI languages which do not belong to the set of Linear Indexed Languages .1. The following languages can be generated by a Global Index Grammar: • Lm = {a1 n a2 n . • L(Gmix ) = {w|w ∈ {a. Recently Rivas and Eddy [64] proposed an algorithm which is O(n6 ) to predict RNA structure including pseudoknots.1. which is in time O(n6 ). b. which we call Global Index Languages.. and proposed a formal grammar [65] corresponding to the language that can be parsed using such an algorithm.1. b}∗ } unbounded number of copies or repeats (which allows also an unbounded number of crossing dependencies). dependent branches There are many similarities between Linear Indexed Grammars and Global Index Grammars. • L(Gwwn ) = {ww+ |w ∈ {a. Probably the work by Searls is the most salient in this ﬁeld. • L(Ggenabc ) = {an (bn cn )+ | n ≥ 1} unbounded number of agreements. However there is no known algorithm that decides the recognition problem for String Variable Languages. are characteristic of the language of DNA. We will show that the automaton and grammar model proposed here extends in a natural way the properties of Push Down Automata and context-free languages. c}∗ and |a|w = |b|w = |c|w ≥ 1} The mix language. 1. combinations.

An abstract family of languages (AFL) is a family of languages closed under the following . We also discuss the structural descriptions generated by GIGs along the lines of Gazdar [29] and Joshi [82. a property which can be proved following the proof presented in [37] for counter automata. We detail the properties of GILs in the following section. and there is no correlation between the recognition problem complexity and the expressive power. GILs are also semi-linear. A subset of GIGs (trGIGs). 1. given they contain the MIX (or Bach) language [11].6 CHAPTER 1. GILs include multiple copies languages and languages with any ﬁnite number of dependencies as well as the MIX language. is also presented in Chapter 3. We present the corresponding grammar model : Global Index Grammars (GIGs). The fourth property. a proof of equivalence between the grammar model and the automaton model (the characterization Theorem) and a Chomsky-Sch¨tzenberger representation Theorem are presented in Chapter 3. This suggests that Linear Indexed Languages might be properly included in the family of Global Index Languages. 44]. limited cross-serial dependencies does not hold for GILs. although no further implications are pursued. which we call LR-2PDAs in Chapter 2 (a signiﬁcant part of this chapter was published in [18]). INTRODUCTION (LILs). The recognition problem for Global Index Languages (GILs) has a bounded polynomial complexity. We show in Chapter 6 that the relevant structural descriptions that can be generated by LIGs/TAGs can also be generated by a GIG. However GIGs can generate structural descriptions where the dependencies are expressed in dependent paths of the tree.2 Outline of the Thesis and Description of the Results Language Theoretic Aspects (Chapters 2-4) We deﬁne the corresponding Automaton model. The set of Global Index Languages is an Abstract Family of Languages. The initial presentation of Global Index Languages was published in [17]. and the family of Global Index Languages (GILs) in Chapter 3. In addition. Therefore GILs have at least three of the four properties required for mild context sensitivity: a) semi-linearity b) polynomial parsability and c) proper inclusion of context free languages. In this work we will address three aspects of the problem: language theoretic issues. parsing and modeling of natural language phenomena. u In Chapter 4 we discuss some of the closure properties of Global Index Languages and their relationship with other languages.

The construction of the Goto function shows an interesting (though not surprising) fact about GILs: the Goto function deﬁnes a PDA that recognizes the set of viable preﬁxes. We also prove that GILs are semi-linear. for higher level programming languages or deterministic approaches for shallow parsing in natural language. Most of the properties of GILs shown in these chapters are proved using straightforward extensions of CFL proofs. but the indexing mechanism could have a higher impact. e-free homomorphism. OUTLINE OF THE THESIS AND DESCRIPTION OF THE RESULTS 7 six operations: union. for example. However it is O(n) for LR or state bound grammars and is O(n3 ) for constant indexing grammars which include a large set of ambiguous indexing grammars.2. We also give an LR parsing algorithm for for deterministic GILs. The result. The time complexity of the algorithm is O(n6 ). The graph-structured stack enables the computations of a Dyck language over the set of indices and their complements. e-free regular sets. This is due to the fact that GILs inherit most of CFL properties. We also show that GILs are closed under substitution by e-free CFLs.1. concatenation and Kleene star. intersection with regular languages. O(|I|3 · |G|2 · n6 ). The space complexity is O(n4 ). Tree Adjoining Grammars and Head Grammars are weakly . Deterministic LR parsing techniques are relevant. shows that the size of the grammar has the same impact as in the CFG case. catenation. free morphisms and inverse morphisms. such as a non-deterministic Generalized LR parsing. We also show that GILs are closed under intersection with regular languages and inverse homomorphism (proved by construction with LR-2PDAs). LIGs. Parsing (Chapter 5) We present a recognition algorithm that extends Earley’s algorithm for CFGs using a graphstructured stack [80] to compute the operations corresponding to the index operations in a GIG. Kleene star. We show by construction using GIGs that GILs are closed under union. Combinatory Categorial Grammars. They are also the basis for non-deterministic approaches. Natural Language Modeling (Chapter 6) We present a comparison of LIGs and GIGs (some of these results were presented in [20]). We evaluated the impact of the size of the grammar and the indexing mechanism separately.

We discuss the relationship of LIGs with GILs in depth in section 6.8 CHAPTER 1.2. LCFRLs LILs CFLs ww anbncn ww + an(bncn ) + GILs Figure 1. We also show that GIGs can generate trees with dependent paths. so the descriptive power of CFGs regarding by natural language phenomena is inherited by GIGs.1. Our conjecture is that it is. Those natural language phenomena that require an extra power beyond CFLs can be dealt with GILs with much more ﬂexibility than with LILs/TALs. INTRODUCTION equivalent. we disscuss how some properties of HPSGs can be modeled with GIGs (presented in [19]. The question still to be answered is whether the area with lines in the LILs and LCFR languages set is empty or not. The set inclusion relation between CFLs. Finally.1: Language relations . and GILs can be represented as in ﬁgure 1. Other formalisms that might share structural similarities with GIGs could be Minimalist Grammars and Categorial Grammars. GILs include CFLs by deﬁnition. There is a long and fruitful tradition that has used those formalisms for Natural Language modeling and processing. LILs/TALs.

2 It is well known that an unrestricted 2-PDA is equivalent to a Turing Machine (cf. 9]. also generalized models of multistacks (e.[7.g.g..g. and n-Stack PDA.. 9 . The model of 2-PDA that we want to explore here is a model which preserves the main characteristics of a PDA but has a restricted additional storage capacity: allows accessing some limited left context information. in the sense that it is forced to consume the input from left to right and has a limited capacity to go back from right to left. Consequently it is possible to simulate the capacity that a TM 1 See [7. (e.[31. The simulation of a TM by a 2-PDA is enabled by the possibility of representing the head position and the tape to the left side of the head in a TM with one stack and the tape to the right side with the second stack. Restricted classes of PDA with two stacks (2-PDA) were proposed as equivalent to a second order EPDA1 . 2 E. 85]. 84]). We need to guarantee that the proposed automaton model does not have the power of a Turing Machine. 84. 21.Chapter 2 Two Stack Push Down Automata 2. 83. 81. or multi-store PDAs as equivalent to n-order EPDA.1 Automata with two Stacks Diﬀerent models of 2-Stack Push Down Automata have been proposed. but behaves like a PDA. [41]).. 59] [21. Those models restrict the operation of additional stacks (be embedded or ordered) allowing to read or pop the top of an additional stack only if the preceding stacks are empty.

st1 . it is not possible to write into the auxiliary stack. Consequently it is possible to “use” the information stored in the auxiliary stack only once. .. TWO STACK PUSH DOWN AUTOMATA has to move from left to right and from right to left. stn ) where sb1 . 13]).. either reading or replacing symbols. because once the input is consumed... . [83. Moving back to the left. Its expressive power is beyond PDA (context free grammars) and possibly beyond EPDA (e. current state. In 2. TAGs). M’. st2 .. 3 We might restrict even more the operation of the auxiliary stack disallowing moves that pop symbols from the auxiliary Stack. In order to simulate these movements in a 2-PDA.. is similar to a PDA. st2 . the input must be consumed and it must be possible to transfer symbols from one stack to the other. Given that it is not possible to re-store them again in the auxiliary stack.. .3. the input might be initially stored in the second stack (e. We adopt the following restrictions to the transitions performed by the kind of 2-PDA we propose here: the Main stack behaves like an ordinary PDA stack (allows the same type of transitions that a PDA allows)..10 CHAPTER 2. ..3 These constraints force a left to right operation mode on the input in the LR-2PDA..3 we deﬁne the LR-2PDA. sbm are a ﬁnite number of stacks introduced below the current stack. and the LR-2-PDA is presented in section 2. and st1 . Alternatively. stn are stacks introduced above the current stack. A more detailed comparison of TMs. sb2 . sb2 .g. The number of stacks is speciﬁed in each move. “erases” the symbols as they are removed from the stack. PDAs. 2. except that the push-down store may be a sequence of stacks. a 2nd order PDA in the progression hierarchy presented in [86]. stack symbol)= (new state. However transitions that push a symbol into the second auxiliary stack do not allow moves..1..1 EPDA and equivalent 2 Stack Machines An EPDA.g. sbm . sb1 . In the next two subsections we review some models that proposed 2-stack or nested stack automata... Consequently this would produce a more restricted set of languages. push/pop on current stack. Then a transition function looks like (from [45]): δ (input symbol. they cannot be recovered (unless some more input is consumed). . It is initiated as a PDA but may create new stacks above and below the current stack.

1. so as to separate diﬀerent sub-stacks. It allows the NPDA. to recognize crossed dependencies as in the example depicted in the next ﬁgure: Figure 2. Symbols written in the second stack can be accessed only after the preceding stack is empty. The possible moves for a 2-SA automaton are the following [7]: • Read a symbol from the input tape .1: Dutch Crossed Dependencies (Joshi & Schabes 97) 2 Stack automata (2-SA) were shown to be equivalent to EPDA [7. 59]. They also require the use of a symbol for the bottom of the stack.2. AUTOMATA WITH TWO STACKS 11 The possibility of swapping symbols from the top stack to embedded stacks produces the context sensitive power of L2 languages in Weir’s hierarchy. for instance. 81. they use the additional stack in the same way as the embedded stacks are used in the EPDA.

Growing Context Sensitive Languages (deﬁned by a syntactic restriction on context sensitive grammars) and the corresponding model of two pushdown automata (see [24. is deﬁned as follows: Deﬁnition 1 a) A TPDA is a 7-tuple M = (Q. 15. but {an bn cn |n ≥ 1} is a GCSL. δ. The shrinking-TPDA. But this restriction is not related to conditions on the the main stack but to conditions on the input. the main stack • push a string onto the auxiliary stack. Wartena [85] shows the equivalence of the concatenation of one-turn multi-pushdown automata restricted with respect to reading (as in the 2-SA case). The recognition problem for growing context sensitive grammars is NP-complete ( [14]). q 0 . 16. The kind of automata we present implements a restriction on the writing conditions on the additional stack. b}∗ } belongs to CSL \ GCSLs. The TPDA initializes the input in one of the stacks. The reading/writing restriction is related to the requirement that the preceding stacks be empty. or pop a symbol from. • pop a symbol from the auxiliary stack provided the main stack contains the bottom of the stack symbol • create a new set of empty stacks (add a string of bottom of the stack symbols).1. Σ. 2. n . In [16] Buntrock and Otto’s Growing Context Sensitive Languages (GCSLs) are characterized by means of the Shrinking Two Pushdown Automata (sTPDA). 53. GCSLs are a proper subclass of CSLs: The Gladkij language {w#wR #w | w ∈ {a. TWO STACK PUSH DOWN AUTOMATA • push a string onto. F ). Γ.12 CHAPTER 2. ⊥. and the alternative restriction with respect to writing. 58].2 Shrinking Two Pushdown Automata Recently there has been interest on Church-Rosser Languages. • remove bottom of the stack symbols. GCSLs contain the non-context-free and non-semi-linear {a2 |n ≥ 0} [16] The copy language is not a GCSL {ww|w ∈ {a. b}∗ }. where • Q is the ﬁnite set of states.

a. Part c) is a relaxation of the previous one and enables . We use a standard notation similar to the one used in [77] or [41]. the next symbol read and the top symbols of the stacks determine the next move of a LR-2PDA.. 2. and the requirement that every move must be weight reducing [57]. u.e.e. The current state. b) then φ(puv) < φ(qab). • ⊥ ∈ Γ \ Σ is the bottom marker of pushdown store.2 Left Restricted 2 Stack Push Down Automatas (LR2PDAs) We deﬁne here the model of automaton that we described and proposed at the beginning of this section. We can consider the automaton model we present in the next section as preserving a shrinking property that conditions the use of the additional stack: it has to consume input.2. The deﬁnition of the transition function δ ensures that transitions with epsilon moves are allowed only if they do not push a symbol into the auxiliary stack. v) ∈ (δ. b) A TPDA is M is called shrinking if there exists a weight function φ : Q ∪ Γ → N+ such that for all q ∈ Q and a. if it is not ). causing the machine to move without reading a symbol from the input or from the stacks. only if they are equivalent to a PDA transition function. otherwise it is equivalent to a TM. The restriction is implemented using a weight function over the automaton conﬁguration.2. LEFT RESTRICTED 2 STACK PUSH DOWN AUTOMATAS (LR-2PDAS) • Σ is the ﬁnite input alphabet. Part b) enables transitions that aﬀect the auxiliary stack if and only if an input symbol is consumed (i. • Γ is the ﬁnite tape alphabet with Γ • q 0 ∈ Q is the initial state. Either of these symbols may be . and • d : Q × Γ × Γ → P(Q × Γ∗ × Γ∗ ) Σ and Γ ∩ Q = ∅ 13 It can be seen that this kind of automaton needs some restriction. i. • F ⊆ Q is the set of ﬁnal (or accepting) states. b ∈ Γ if (p. Part a) in the deﬁnition of the transition function is equivalent to a PDA.

and F are all ﬁnite sets and 1. For Natural Language purposes it might be desirable to keep stronger restrictions on the auxiliary stack. Γ. 2. but this would rule out reduplication (copy) languages (See the introduction) as we will see below. Σ. ⊥. Q × Σ × Γ × Γ → P F (Q × Γ∗ × Γ2 ) c. If part c) is removed from the deﬁnition a diﬀerent class of automata is deﬁned: we will call it sLR-2PDA. and Γ is Γ ∪ { } ) : a.14 CHAPTER 2. 3. Q × (Σ ∪ { }) × Γ × { } → P F (Q × Γ∗ × { }) and 4 The two transition types a. q 0 ∈ Q is the start state 6. F ) where Q. Deﬁnition 2 A LR-2PDA is a 7-tuple (Q. Σ is the input alphabet. 4. Γ. Q × (Σ ∪ { }) × Γ × { } → P F (Q × Γ∗ × { }) and b. δ. ⊥ ∈ Γ \ Σ is the bottom marker of the stacks 7. can be conﬂated in: a’. and c. The set of languages that can be recognized by a sLR-2PDA is therefore a proper subset of the set of languages that can be recognized by a LR-2PDA. q 0 . Γ is the stacks alphabet. δ is the transition function ( where P F denotes a ﬁnite power set. We keep them separate to show the parallelism with the type of productions in the grammar model. Q × (Σ ∪ { }) × Γ × Γ → P F (Q × Γ∗ × { }) . The auxiliary stack should be emptied only consuming input. . TWO STACK PUSH DOWN AUTOMATA -moves that pop elements from the second stack. Q is the set of states. Q × (Σ ∪ { }) × Γ × Γ → P F (Q × Γ∗ × { })4 5. Σ. F ⊆ Q is the set of accept states. Deﬁnition 3 A sLR-2PDA is a LR-2PDA where δ is: a. Such a restriction could be accomplished in the sLR-2PDA case because the auxiliary stack cannot be emptied using -moves.

⊥. w. state and stack contents.3 Comparison with TM. There is a work space (storage data structure) that also can be transversed only once (as soon there is a move to the left. Reads left to right only. COMPARISON WITH TM. w. then (q. that can be also used and reused at any time. An ID is a 4-tuple (q. ⊥. A clear example of maximum transversal and input storage is the language Lr = {wwR | w ∈ Σ∗ } which can be recognized by a PDA. but it cannot recognize Lc = {ww | w ∈ Σ∗ } which would require additional use of the storage capacity. 2. γ 1 . δ. The reﬂexive and transitive closure of M M (p. ⊥. a. Q × Σ × Γ × Γ → P F (Q × Γ∗ × Γ∗ ) 15 The instantaneous descriptions (IDs) of a LR-2PDA describe its conﬁguration at a given moment. plus it has an unlimited work-space. Zα.2: A Turing Machine A PDA: The input can be transversed only once. . w. aw. Writes left to right or same cell Independent operation: allows e-moves Moves to the left erasing. O) M. Σ. If M = (Q. ⊥) (Acceptance by empty stacks) (p. η). ηβ) if δ(q. q 0 . F ) is {w | (q 0 . γ 2 ) where q is a state w is a string of input symbols and γ 1 . δ. from left to right. ⊥. whatever remains at the right is forgotten). ζ. ⊥)} for some p in F . Oβ) contains (p.3. Γ. Figure 2. γ 2 are strings of stack symbols. PDA AND LR-2PDA b. PDA and LR-2PDA A Turing Machine: the input tape is also a storage tape. The input can be transversed as many times as desired. ∗ is denoted by ∗ The language ac- cepted by a LR-2PDA M = (Q. Read and Write one cell One head Figure 2. It has the capacity of remembering a sequence of symbols and matching it with another equal length sequence. They specify the current input.3: A PDA . Γ. ζα. Z.2. Σ. q 0 . F ) is a LR-2PDA.

then the possibility of storing information from the input seen at this move is lost. While recognizing the second copy all the information stored about the ﬁrst copy is lost. Transfer from one stack to the other is restricted. u) = (q 3 . but it can store again in the second stack (the second copy). (q 3 . In order to avoid the possibility of transferring symbols from one stack to the other indeﬁnitely. but unlike a TM. a. The following languages which can be recognized by an LR-2PDA are examples of a maximum use of the storage of the input: L2ra = {wwR wR w | w ∈ Σ∗ } and L2rb = {wwR wwR | w ∈ Σ∗ }. from left to right. a.16 CHAPTER 2. However. ) = (q 1 . This exempliﬁes how many times (and the directions in which) the same substring can be transversed. (above) . given the constraints imposed on LR-2PDAs. and store the symbols of the second copy back A loop back from state q 3 to state q 2 allows recognition of the language of any ﬁnite number of copies (example 2). if information from the ﬁrst ordered stack is transferred to the second auxiliary stack. . consequently what is being read cannot be stored in the main or the auxiliary stack if there is a transferral occurring. (q 2 . au) (recognize the second copy using the symbols stored in the main stack. TWO STACK PUSH DOWN AUTOMATA A LR-2PDA: The input can be transversed only once. The crucial fact is that transitions type c. (q 1 . a. an LR-PDA can recognize the language L3 = {www | w ∈ Σ∗ }. The corresponding machine is detailed below in the exsection 2. This capacity is reduced even further in the case of sLR-2PDA: both types of operations on the auxiliary stack are made dependent on consuming input. a) = (q 2 . .4. 1. Consider the following transitions (where a is a symbol in Σ). whatever remains at the right is forgotten). ) (transfer symbols from auxiliary to main stack) 3. A sLR-2PDA cannot recognize the copy language: if the auxiliary stack is used to store all the symbols of the input tape then it would be of no more use than storing all the symbols in the main stack: the symbols can only be transferred from the auxiliary stack to the main stack only if the input tape is being read. . a LR-2PDA is not able to transverse a substring indeﬁnitely. There are two work- spaces which also can be transversed only once (as soon there is a move to the left. a) (store the symbols of the ﬁrst copy) 2. . a. the second storage can be written to only when consuming input. .

e}. {x}. M 5 = ({q 0 . b.4. 17 Writes left to right or same cell Moves to the left erasing. c. q 0 . δ. q 3 }. Writes left to right or same cell Independent both operations. Independent both operations. q 2 . Dependent moving (erasing) Figure 2. Writes left to right or same cell Moves to the left erasing. Example 1 (Multiple Agreements) . Writes left to right or same cell Transfer NOT possible Dependent writing from 1. q 1 . d.2. q 3 ) where δ: . Moves to the left erasing. Transfer possible Dependent writing from 1. Figure 2. {a. Independent moving. Moves to the left erasing. EXAMPLES OF LR-2PDAS Reads left to right only.4: LR-2PDA are not allowed. Reads left to right only. Examples 2 and 3 are LR-2PDAs.5: sLR-2PDA 2. w ∈ Σ∗ and |w| ≤ |u|} is recognized by a sLR-2PDA. ⊥. However the language L = {wuw | u.4 Examples of LR-2PDAs The ﬁrst example is a sLR-2PDA.

where k > 3. $ . $) = accept 6 Figure 2.a’) = ($. c . δ(q 1 . b. x⊥)} 4. c . ak }. ε) ( d . ⊥) = {(q 1 . ⊥)} 12.18 Three counting dependencies M1 0 CHAPTER 2.. ⊥. e. c. ⊥) = {(q 1 .$. ε ) 1 (a. ⊥)} 8. ⊥. (q 1 . d. δ(q 2 .a’) = (cc. )} 6. ⊥)} 3. x. b. ⊥) = {(q 2 . . x. . δ(q 1 . x⊥). ⊥. δ(q 0 . x) = {(q 1 . xx} 9.a. ⊥)} 2. ⊥.$. a’ ) = ( ε. $) = accept 5 5 ( e. c . ⊥) = {(q 1 . d. )} L(M 5 ) = {an bn cn | n ≥ 1} ∪ {an bn cn dn | n ≥ 1} ∪ {an bn cn dn en | n ≥ 1} It can be easily seen that the following is a proper generalization: Claim 1 For any alphabet Σ = {a1 . ). . δ(q 2 . ⊥. ε ) (c. $) ( d . c . ε ) ( [] . ⊥. ε ) (b.6: Multiple agreement in an sLR-2PDA 1. $ . x) = {(q 2 .a’) = (c$. ε ) Idem 3 (c. δ(q 1 . TWO STACK PUSH DOWN AUTOMATA Four Counting Dependencies M2 Five Counting dependencies M3 (a.. ε ) = (aa. δ(q 1 . x. $) = accept (c. x. x) = {(q 1 . ⊥. ⊥. x⊥. xx}) 5. c’) = ( ε. δ(q 1 .a’) = ($. c’$) 4 4 ( d . x. a. ε ) ( [] .a. )} 11.a’a’) (c. x⊥. $ ) = (ε . e. $ .. c’) = ( $ . $) = ( ε. (q 2 . )} 7. x) = {(q 1 . .an | n ≥ 1} 1 2 k .a’$) Idem 2 (b. δ(q 2 . )} 10. ⊥. . $ . x. xx. δ(q 1 . ⊥) = {(q 1 . ε) = (a$. ε ) = ( ε. a. x) = {(q 2 . c’c’) ( e . d. ε ) 3 ( [] . x. there is an sLR-2PDA that recognizes the language L(M k ) = {an an .. $ . δ(q 1 . c ..$. ε ) 4 ( d . x) = {(q 2 . xx. δ(q 1 . . c. $ . c’) = ( $ .a. x) = {(q 2 . c. . $) = ( ε.

⊥. )} L(M 4 ) = {ww+ |w ∈ {a. yu). . a. δ(q 3 . ⊥. b. )} 6. ⊥. δ(q 2 . . a2 ⊥)} 4. δ(q 1 . a1 . a1 . ⊥) = {(q 3 . ⊥) = {(q 1 . ⊥) = {(q 1 . a. ⊥. q 0 . ⊥. ao . x) = {(q 2 . ⊥. ⊥. (q 3 . )} if k is odd or 10. Example 2 (The language of multiple copies) M wwn = ({q 0 . a2 ) = {(q 1 . δ(q 2 . ⊥. δ(q 0 . ae ae } and 9. δ. a1 . ⊥. )} 14. u) = {(q 3 . y) = {(q 2 . ⊥. ⊥.t. . . ⊥)} 11. e ≥ 3 < k and o is odd and e is even: 1. transitions 1 to 4 recognize the ﬁrst occurrence of w. ao−1 ) = {(q 1 . . a1 a1 . δ(q 1 . a2 . δ(q 0 . ⊥)} 12. . δ(q 1 . ⊥. ao ⊥. . u) = {(q 1 . δ(q 1 . yw. Σ. q 3 ) where δ (s. ak −1 . δ. y) = {(q 2 . δ(q 1 . y⊥)} 3. ⊥)} 3. If an intermediate copy is recognized transitions 13 and 14 allow going back to state 2 and reverse the order of the stored symbols. x) = {(q 2 . δ(q 1 . δ(q 1 . ak . )} 9. ao ao . . y}. xw. )} 7. ⊥. δ(q 1 . ⊥)} if k is even. q 2 . x⊥. ⊥) = {(q 1 . ⊥)} 2. x⊥). q 0 . ak −1 ) = {(q 2 . u) = {(q 3 . ak . xu). q 1 . . b}+ } 8. ao . u) = {(q 1 . ae . )} . )} 7. ⊥) = {(q 1 . y⊥). w. reverse the order of the stored symbols. xu)} 4. ao .4. x⊥)} 2. q 2 ) where δ is as follows. ae−1 . y. such that o. x. Σ. ⊥. q 3 }. ⊥. δ(q 2 . y. a1 . δ(q 3 . ⊥) = {(q 1 . . y⊥. a. ⊥) = {(q 1 . b}. ⊥)} 10. ⊥) = {(q 2 . . . δ(q 0 . δ(q 2 . x. x) = {(q 2 . . (q 3 . a1 . δ(q 3 . a2 a2 }) 5. ae−1 . . ⊥)} 13. ⊥. a. . δ(q 1 .2. δ(q 1 . )} 6. (q 3 . y⊥. b. (q 3 . δ(q 1 . transitions 9 to 12 recognize either the following copy or the last copy. In the next example. transitions 5 to 8. δ(q 1 . ⊥. ⊥) = {(q 3 . ao−1 ) = {(q 1 . ae ⊥)} 8. y) = {(q 2 . a1 ⊥. δ(q 3 . q 1 . yu)} 5. ae ) = {(q 1 . {x. . q 2 }. b. b. . a2 . δ(q 1 . EXAMPLES OF LR-2PDAS Proof Construct the sLR-2PDA M k as follows: 19 M k = ({q 0 . . u is any symbol in the vocabulary): 1. ⊥. {a. ae . . w. x⊥.

I ∈ Γ. a. m. δ(q 1 . d. . z⊥. ⊥) = {(q 1 .5. ⊥. d. {x. y. for each q ∈ Q. A. . zz)} 7. ⊥)} 14. a. d. )} 13. for no q ∈ Q. I ∈ Γ. Z. e. yy)} 12. z) = {(q 2 . . δ(q 2 . x) = {(q 1 . q 0 . then δ(q.20 CHAPTER 2. b. ⊥. . . for each q ∈ Q and Z. x⊥)} 2. 2]. x) = {(q 1 . )} L(M cr3 = {a b c d e f | n. . z. ⊥. A. y) = {(q 1 . whenever δ(q. )} 10. a. ⊥. l ≥ 1} n m l n m l 9. f }. TWO STACK PUSH DOWN AUTOMATA Example 3 (Crossed dependencies) M cr3 = ({q 0 .5 Determinism in LR-2PDA An LR parser for a CFL is essentially a compiler that converts an LR CFG into a DPDA automata [41. y) = {(q 1 . I) contain more than one element. x. δ(q 1 . δ(q 2 . ⊥) = {(q 3 . ⊥. Deterministic GILs are recognized in linear time as we mentioned in the introduction. ⊥) = {(q 3 . ⊥)} 2. . ⊥) = {(q 3 . δ(q 2 . yx)} 4. ⊥. x. y. The corresponding deﬁnition of a deterministic LR-2PDA is as follows: 2. δ(q 1 . δ(q 1 . a. xx)} 3. ⊥. q 3 }. z) = {(q 1 . Z. q 3 ) where δ: 1. δ(q 1 . I) is empty for all I ∈ Γ. ⊥. Z. c. )} 11. . z. . y) = {(q 1 . zz. ⊥. ⊥) = {(q 3 . δ(q 2 . c. ⊥. {a. whenever δ(q. δ(q 0 . z}.1 Deterministic LR-2PDA Deﬁnition 4 A LR-2PDA is deterministic iﬀ: 1. y. I ∈ Γ. A ∈ Σ and Z. yy. x) = {(q 1 . c. I) is empty for all a ∈ Σ. b. ⊥. ⊥. z. Z. y. δ(q 3 . . e. δ. I) is nonempty. yz. f. z) = {(q 1 . b. ⊥)} 15. xy. q 2 . . 3. ⊥. ) is nonempty. ⊥)} 5. δ(q 1 . then δ(q. δ(q 3 . δ(q 2 . ⊥. zy)} 6. Z. δ(q 3 . Therefore understanding the deterministic LR-2PDA is crucial for obtaining a deterministic LR parser for GILs deﬁned in chapter 6. y) = {(q 1 . )} 8. q 1 . 2. and a ∈ Σ ∪ { } does δ(q. Z.

a. The construction of the LR(k) parsing tables would show whether the indexing mechanism for a given GIG is non-deterministic. I ∈ Γ. I) contain two elements = (q i . whenever δ(q. for each q ∈ Q and Z. I j ) such that I i = I j . for no q ∈ Q. A ∈ Σ and Z. 1. it might be an advantage to be able to determine whether the non-determinism lies in the CFG back-bone only and the indexing mechanism does not introduce non-determinism. . (q. Condition 2 prevents the choice of move for any equal 4-tuple. Z. Z. in the following examples of transitions. Therefore. i) 3. or is a deterministic indexing LR-2PDA if and only if: 1. nor with the fourth. and a ∈ Σ ∪ { } does δ(q. j) 2. Z. (q. I) is empty for all a ∈ Σ. (q. I ∈ Γ. a. . Z j .2 LR-2PDA with deterministic auxiliary stack Even if a GIG grammar is non-deterministic. . DETERMINISM IN LR-2PDA 21 Condition 1 prevents the possibility of a choice between a move independent of the input symbol ( -move) and one involving an input symbol. ) is nonempty. A. j) 4. We can regard to be an abbreviation for all the possible symbols in the top of the stack. I i ) and (q j . the ﬁrst case is not compatible with the third.2. a. I) is empty for all I ∈ Γ. . i) = (q. . 3. ) 2. Deﬁnition 5 A LR-2PDA has a deterministic indexing. then δ(q. then δ(q.5. . . whenever δ(q. Z. Z. b. for each q ∈ Q. ) = (q. because they imply a non-deterministic choice. j) = (q. If the non-determinism is in the CFG backbone only we can guarantee that the recognition problem is in O(n3 ). . A. (q. Z. Z i . . a. 2. Condition 3 prevents the possibility of a choice between a move independent of the second stack symbol ( -move) and one involving a symbol from the stack. a. ) = (q. I ∈ Γ. . I) is nonempty.5.

22 CHAPTER 2. TWO STACK PUSH DOWN AUTOMATA .

P. where N is the set of non-terminal symbols. and α is in (V ∪ T )∗ ..1 Indexed Grammars and Linear Indexed Grammars Indexed grammars. 23 .e. An Indexed Grammar is a 5-tuple (N. The relation derives. ⇒. δ be in I ∗ .] represents a stack of indices. As a consequence they are semi-linear and belong to the class of MCSGs. strings in (V I ∗ ∪ T )∗ . A → α b. Let β and γ be in (V I ∗ ∪ T )∗ . S).Chapter 3 Global Index Grammars 3. and X i in V ∪ T . have the capability to associate stacks of indices with symbols in the grammar rules..] c. i is in I ..LILs) [29].]α n where A and B are in V . T the set of terminals. on sentential forms. (IGs) [1].. [. LIGs are Indexed Grammars with an additional constraint on the form of the productions: the stack of indices can be “transmitted” only to one non-terminal.. IGs are not semi-linear (the class of ILs contains the language {a2 | n ≥ 0}). The class of LILs contains L4 but not L5 (see Chapter 1). T. S in V is the start symbol.] → [. a string in I ∗ .. A[.] → B[i. and Linear Index Grammars. (LIGs. I the set of indices. i. and P is a ﬁnite set of productions of the form: a. I. A[i. is deﬁned as follows.

where P is: S[. G1 = ({S.. In this sense...X k is a is a production of type c.] → A[.. If A[. B}. The introduction of indices in the derivation is restricted to rules that have terminals in the right-hand side.. the stack of indices is associated with variables.. This feature makes the use . where A and B are non terminals and α and γ are (possible empty) sequences of terminals and non terminals: a.] → α B[.X k is a production of type a. A[. P.] → bB[...].. If A → X 1 .]c.2 Global Index Grammars In the IG or LIG case.24 CHAPTER 3. Example 4 L(G1 ) = {a2 n ≥ 0}.] γ b.] A[] → a A Linear Indexed Grammar is an Indexed Grammar where the set of productions have the following form.. {i}. then βAδγ ⇒ βBxδγ 3. B[ ] → 3..] → α B[. GIGs are a kind of regulated rewriting mechanism [25] with global context and history of the derivation (or ordered derivation) as the main characteristics of its regulating device..]..]d.] is a production of type b. A[i. The proposal we present here uses the stack of indices as a unique designated global control structure. then βAxδγ ⇒ βX 1 δ 1 .. 2.] γ c. A}..] → aS[i. c.] → B[x..] A[. these grammars provide a global but restricted context that can be updated at any local point in the derivation. S[. B[i..] → A[. d}... A[. P.. S).. S) where P : S[. then βAδγ ⇒ βX 1 δ 1 ....]A → [.X k δ k γwhere δ i = δ if X i is in V and δ i = n if X i is in T..] A[.] → B[...] → αB[i. b.] A[i. If [x. GLOBAL INDEX GRAMMARS 1. S[.] → S[i.X k δ k γ where δ i = δ if X i is in V and δ i = if X i is in T.] γ Example 5 L(G1 ) = {an bn cn dn |n ≥ 0}.. It is a grammar that controls the derivation through the variables of a CFG. G1 = ({S... {i}. {a.. {a}..] X 1 .

δ be in I ∗ .]α [. In the next subsection we present an even more restricted type of GIG that requires both push and pop rules in Greibach Normal Form..]α (epsilon rules or context free (CF) rules ) (epsilon rules or CF with constraints) (push rules or opening parenthesis) (pop rules or closing parenthesis) b. A ∈ N . T..... Let β and γ be in (N ∪ T )∗ .1 A → α a. The notation at the right is intended to be more similar to the notation used in IGs and LIGs. I are ﬁnite pairwise disjoint sets and 1) N are non-terminals 2) T are terminals 3) I a set of stack indices 4) S ∈ N is the start symbol 5) # is the start stack symbol (not in I..X k is a production of type a. Derivations in a GIG are similar to those in a CFG except that it is possible to modify a string of indices.1 where x ∈ I. x ∈ I) then: δ#βAγ ⇒ δ#βX 1 .. α. Pop rules do not require a terminal at all.3.e. y ∈ {I ∪ #}.]A → [. µ = µ or µ = [x]. Deﬁnition 6 A GIG is a 6-tuple G = (N. w be in T ∗ and X i in (N ∪ T ).. A → a β x c. An additional constraint imposed on GIGs is strict leftmost derivation whenever indices are introduced or removed by the derivation. I..2 A → α [y] or or or or A→α [. #.2) [x] 1 The notation at the left makes explicit that operation on the stack is associated to the production and not to terminals or non-terminals.2. β ∈ (N ∪ T )∗ and a ∈ T . We deﬁne the derives relation ⇒ on sentential forms.. and allows the kind of recognition algorithm we propose in Chapter 5.X k γ Using a diﬀerent notation: δ#βAγ ⇒ δ#βX 1 . 1. If A → X 1 . This string of indices is not associated with variables. without it GIGs would be equivalent to a Turing Machine. A → α x ¯ Note the diﬀerence between push (type b) and pop rules (type c): push rules require the righthand side of the rule to contain a terminal in the ﬁrst position.X k γ (production type a. T. The constraint on push rules is a crucial property of GIGs.X k γ) (production type a. in a linguistic sense. a.1 or context free ) xδ#βAγ ⇒ xδ#βX 1 . GLOBAL INDEX GRAMMARS 25 of indices dependent on lexical information.. .N .T ) and 6) P is a ﬁnite set of productions...]A → [. [39]). having the following form. P ) where N.]A → [x. x in I. It also makes explicit that the operations are associated to the computation of a Dyck language (using such notation as used in e.. S. (i.g.]a β [x. so we can consider them global. which are strings in I ∗ #(N ∪ T )∗ as follows.

with the consequence that LILs are semilinear.X n γ µ ( or δ#wAγ ⇒ xδ#waX 1 .) or push: µ = x.b) (in other words push productions must be in Greibach Normal Form). the stack of indices in a GIG is independent of non-terminals in the GIG case. Deﬁnition 7 A trGIG is a GIG where the set of production of types (c) (pop) rules.. GLOBAL INDEX GRAMMARS This is equivalent to a CFG derives relation in the sense that it does not aﬀect the stack of indices (push and pop rules). β ∈ (N ∪ T )∗ .. In LIGs indices are associated with only one non-terminal at the right-hand side of the rule. is the interpretation of the derives relation relative to the behavior of the stack of indices. We deﬁne the language of a GIG G. The derives deﬁnition requires a leftmost derivation for those rules (push and pop rules) that aﬀect the stack of indices.] a β . then: ¯ xδ#wAγ ⇒ δ#wX 1 . where x ∈ I.X n γ ) x 3. are as follows. but to an extreme: there is only one stack to be considered.... LIGs and GIGs. In IGs the stacks of indices are distributed over the non-terminals on the right-hand side of the rule. If A → aX 1 ..X n γ ) x ¯ ∗ The reﬂexive and transitive closure of ⇒ is denoted as usual by ⇒. L(G) to be: {w|#S ⇒ #w and w is in T ∗ } It can be observed that the main diﬀerence between. A ∈ N . α.. ∗ 3.) or pop : µ = x. We also introduce some examples of trGIGs modeling multiple agreements and crossed dependencies. GIGs share this uniqueness of the stack with LIGs.. GIGs can have rules where the right-hand side of the rule is composed only of terminals and aﬀects the stack of indices.1 trGIGS We now deﬁne trGIGs as GIGs where the pop rules (type c. x ∈ I.]A → [. IGs..2. This produces the eﬀect that there is only one stack aﬀected at each derivation step. and a ∈ T : c. then: µ δ#wAγ ⇒ xδ#waX k .) are constrained to start with a terminal in a similar way as push (type b. 2.. x ∈ I.X n is a production of type (c. A → a β x ¯ or [x..... x ∈ I.X n γ ( or xδ#wAγ ⇒ δ#wX 1 . If A → X 1 ...) rules in GIGs.26 CHAPTER 3. Indeed push rules (type b) are constrained to start the right-hand side with a terminal as speciﬁed in GIG’s deﬁnition (6.X n is a production of type (b. Unlike LIGs and IGs..

#.. S → a1 S E 2 3a. . a j }. and P is composed by: 1. B. O3 . P ) and P is: S → AR L → OR | C A → aAE ¯ i A→a ¯ i E→b i R→bL i C→cC|c O → c OE | c . Ggdp = ({S. c.an | n ≥ 1.. S→ a1 E 2 4a. a 4 . k ≥ 4} is in trGIL 1 2 k Proof Construct the GIG grammar Gk = ({S. D. b. #. Ok → ak ak −1 ¯ L(Gn ) = {a1 a2 . b. {a. S → A D 2.3. P ) such that k ≥ 4 and j = k if k is even or j = k − 1 if k is odd... A.. . C}. {a. S..ak | n ≥ 1. e}.. S. {a 2 . .2. E i → ai Oi+1 ai and for every E i and Oi such that i is odd in Oi and i is even in E i add the following rules: 5a. Ak → ak Ak ak −1 ¯ n 4b. c}. S. Ak → ak 6b. O. D → d D | d x ¯ Now we generalize example 6 and show how to construct a trGIG that recognizes any ﬁnite number of dependencies (similar to the LR-2PDA automaton presented in the previous chapter): Claim 2 The language Lm = {an an .E i → ai E i ai ai−1 ¯ 2. E}. E. g }. {i}. c. G5 = ({S. ak }. GLOBAL INDEX GRAMMARS Example 6 (multiple agreements) L(G5 ) = {an bn cn dn en | n ≥ 1}. {a.. R.. P ) and P is: S → ACE C → cD ¯ i 27 A → aAb i A → ab i ¯ j ¯ j C → cD1 ¯ i D1 → CD D→d j E → eE E→e The derivation of w = aabbccddee: #S ⇒ #ACE ⇒ i#aAbCE ⇒ ii#aabbCE ⇒ i#aabbcD1 E ⇒ i#aabbcCDE ⇒ #aabbccDDE ⇒ j#aabbccdDE ⇒ jj#aabbccddE ⇒ j#aabbccddeE ⇒ #aabbccddee Example 7 (crossing dependencies) L(Gcr ) = {an bm cn dm | n.. B → b B | b x 4. 4 ≤ k} We can generalize the same mechanism even further as follows: Example 8 (Multiple dependencies) L(Ggdp ) = { an (bn cn )+ | n ≥ 1}. L}. D1 . m ≥ 1}. #. Oi → ai Oi E i+1 ai−1 ¯ 6a. d. E 2 . Ak }. b...Ak → ak Ak 5b. A. {x and P is: 1. {a . C.. Oi → ai E i+1 If k is even add: If k is odd add: n n 3b. A → a A c | a B c 3. d}. {a1 . A. where Gc r = ({S.

R. c. B. B. Above. S. {a.2. {i. {i. S → aS i 2. we mentioned the diﬀerence between push and pop rules in GIGs. This is not possible in trGIGs because pop rules cannot be left recursive. j. j}. F. #. D. f }. #S ⇒ #AR ⇒ #aAER ⇒ #aaER ⇒ i#aabR ⇒ ii#aabbL ⇒ ii#aabbOR ⇒ i#aabbcOER ⇒ #aabbccER ⇒ i#aabbccbRii#aabbccbbL ⇒ ii#aabbccbbC ⇒ i#aabbccbbcC ⇒ #aabbccbbcc 3. S → R 4. b}∗ } Gww = ({S. d.28 CHAPTER 3. P ) and P = S → AS | BS | C B→b j ¯ i C → RC | L L → Lb | b ¯ j R → RA ¯ i R → RB ¯ j R→ [#] A→a i L → La | a The derivation of ababab: #S ⇒ #AS ⇒ i#aS ⇒ i#aBS ⇒ ji#abS ⇒ ji#abC ⇒ ji#abRC ⇒ i#abRBC ⇒ #abRABC ⇒ #abABC ⇒ i#abaBC ⇒ ji#ababS ⇒ ji#ababL ⇒ i#ababLb ⇒ #ababab In the next example. S → bS j 3. It is easy to see that by generalizing the same mechanism any ﬁnite number of crossing dependencies can be generated. R → Rb | b ¯ j The derivation of the string abbabb: #S ⇒ i#aS ⇒ ji#abS ⇒ jji#abbS ⇒ ji#abbRb ⇒ i#abbRbb ⇒ #abbRabb ⇒ #abbabb Example 10 (Multiple Copies) L(Gwwn ) = {ww+ | w ∈ {a. R}. A. b}∗ } Gwwn = ({S. we can see that by using left recursive pop productions we can generate a language with a higher number of crossing dependencies than we can by using a trGIG. k}. E}. #. Example 9 (Copy Language) L(Gww ) = {ww |w ∈ {a. R → Ra | a ¯ i 5. {a. This diﬀerence enables the use of left recursive pop rules so that the order of the derivation is a mirror image of the left-right order of the input string. L.2 GIGs examples We conjecture that the following languages can be deﬁned with a GIG and cannot be deﬁned using a trGIG. e. C. P ) and P = . P ) and P = 1. b. b}. j}. {i. Example 11 (Crossing Dependencies) L(Gcr3 ) = {an bm cl dn em f l } Gcr3 = ({S. GLOBAL INDEX GRAMMARS The derivation of the string aabbccbbcc shows ﬁve dependencies. C}. S. #. {a. b}. S.

It was conjectured in [29] that the MIX language is not an IL. B → bB | bC j ¯ i 2. [11] ). P ) and P is: S → cS i ¯ i ¯ j S → bS j S → aS k S → SaSbS | SbSaS S → SaScS | ScSaS S → SbScS | ScSbS ¯ k S→ L(Gmix ) = Lmix = {w|w ∈ {a. This is important because it is very diﬃcult to build a proof for the claim that the MIX language belongs (or does not belong to) to a family of languages 2 . C → cC | c k 5. . S ⇒ k#aS ⇒ #aSbScS ⇒ #abScS ⇒ j#abbcS ⇒ #abbcScSaS ⇒ #abbccSaS ⇒ #abbccaS ⇒ #abbcca We present here the proof that L(Gmix ) = Lmix . see e. E → Ee | De 7. L → Lf | Ef 6. There are also factorial duplicates for the number of times a character occurs in the string. It allows an incredible number of possible strings of any given length in the language. c}∗ and |a|w = |b|w = |c|w ≥ 1} Example of a derivation for the string abbcca. The number of strings of length 3n is (3n)!/(n!)3 . and 1680 strings of length 9).c. j.2. This language though conceptually simple. turns out to be a very challenging problem. b’s and c’s) are observed. Joshi p. S → F L ¯ k 29 3. Example 12 (MIX language) Gmix = ({S}. F → aF | aB i ¯ j 4. and the need to ensure that the three dependencies (between a’s. as exempliﬁed by Lmcr = {an bm cl dn em f l g n hm il } or {an bm cl (dn em f l )+ } The next example shows the MIX (or Bach) language (the language with equal number of a’s b’s and c’s in any order. We show that GILs are semilinear. and at the same time it requires that three dependencies be observed. b. It is easy to design GIG grammars where the respective languages are in Lmix . k}. In the mix language each character occurs in one third of the string and there are three characters. S. c}. The diﬃculty is due to the number of strings in the language at the basic combination level (there are 90 strings of length 6.g. The number of permutations for a string of length n is n!. however it is not so easy to prove or assess whether the 2 A. {a. #. {i.3. obtaining sets of crossing dependencies. GLOBAL INDEX GRAMMARS 1. D → Dd | d This can be even further generalized. b. therefore ILs and GILs could be incomparable under set inclusion.

We need to prove that ut1 wt2 y t3 z is in L(GMIX ) ( |uti wti y ti z| = n + 3). and t are members of the pairs that remove indices in the derivation. y = a1 y c1 z. S ⇒ jδ #u bS ⇒ δ#u bSaScS ⇒ iδ #u bw caScS ⇒ δ #u bw caay bcS If we try to combine the derivation proposed in 1. where ¯ ¯ ¯ ¯ |uwyz| = n. b. w = w c2 and y = a2 y b2 trigger the following derivation (perhaps the only one). GLOBAL INDEX GRAMMARS language is indeed Lmix . Second direction: Lmix is in L(Gmix ) Basis n = 0. Proof . This blocking eﬀect can be illustrated by the following hypothetical situation: suppose uwyz might be composed by u = u b1 . with the one proposed in 2. S ⇒ δ#uS ⇒ kδ#uaS ⇒ δ#uaSbScS ⇒ δ #uawbScS But at this point the strings b and c might block a possible derivation. c}∗ and |a|w = |b|w = |c|w ≥ 0}. 1. 2. Where ¯ ¯ t1 t2 t3 is any string of length three in Lmix and t designates the terminals that introduce the indices ¯ in the derivation. b s and c s due to the constraint imposed by the indexing mechanism. We show ¯ ¯ that Gmix generates any uti wti y ti z It is trivial to see that the following derivation is obtained (where a corresponds to tk and b and c ¯ to the tk ’s. First direction: L(Gmix ) is in Lmix = {w|w ∈ {a. n ≥ 0. n = 3: S ⇒ k#a ⇒ #abc k ¯ k ¯ k is clearly in the language.30 CHAPTER 3. It can be seen that all the derivations allow only equal number of a s. It might just turn out to be a signiﬁcant subset of Lmix (in other words it is not so easy to ﬁgure out if there are some set of strings in Lmix that might not be generated by a particular grammar). S ⇒ k#a ⇒ #acb k j j i i S ⇒ j#b ⇒ #bac ¯ j ¯ j S ⇒ j#b ⇒ #bca S ⇒ i#b ⇒ #cba ¯ i ¯ i S ⇒ i#b ⇒ #cab Inductive Hypothesis: Assume for any string uwyz in Lmix then uwyz is in L(GMIX ). we reach the following point: ∗ ∗ ∗ ∗ .

(ti .. tj are reduced to the case of two conﬂicting indices.. . Case 1.. removing the index j.: baScacbS where the two non terminal S expand the ti n−1 triples.tj ... This cannot be done because the derivation has to proceed with the preceding S (at a0 Sb0 ) due to the leftmost derivation constraint for GIGs. We prove now that such a blocking eﬀect in the indexing is not possible: there are always alternative derivations.e. This in turn can be easily derived by: δ#S ⇒ jδ#bS ⇒ δ#baScS ⇒ in−1 δ#baan−1 cS ⇒ kin−1 δ#baan−1 caS ⇒ in−1 δ#baan−1 cacbS ⇒ δ#baan−1 cacb(cb)n−1 Claim 4 For any sequence of two possible conﬂicting indices there is always at least a derivation in Gmix . Therefore. In other words. because the grammar is highly ambiguous.ti )n ] And this problem is reduced to: ¯¯¯¯ tj ti S tj tj ti ti S i. Claim 3 For any sequence of possibly conﬂicting indices the conﬂicting indices can be reduced to two conﬂicting indices in a derivation of the grammar Gmix .2. clearly S ⇒ i#ti S ⇒ #ti Stj Stk S and the complements of ti . GLOBAL INDEX GRAMMARS 3. and t are members of the pairs that remove indices in the derivation.. is there any possible combination of indices : ¯ ¯ ¯ ¯ ¯ ¯ ti · · · tj · · · tk · · · tj · · · tk · · · ti · · · tj · · · tk · · · ti that cannot be derived by GMIX ? Remember t designates the terminals that introduce the indices ¯ in the derivation. tk . there is more than one element in one of the indices : ¯¯ ¯¯ ti tj (ti )n [tj tj (ti ti )n+1 ] for example: ab(a)n [cacb](cb)n ab(a)n [accb](cb)n S ⇒ ti S[ti ti ] reduces to the following problem which is derived by the embedded S ¯ ¯ ¯ ¯ tj (ti )n [tj . We need to account whether there is a possible conﬁguration such that a conﬂict of indices arises..3. there are three diﬀerent indices (ti = tj = tk ): ti utj vtk . Case 2. there is no guarantee that the necessary sequence of indices are removed. S ⇒ jδ #u b1 S ⇒ kjδ #u b1 a0 S ⇒ jδ #u b1 a0 Sb0 Sc0 S ∗ 31 At this point the next step should be the derivation of the non-terminal S at b0 Sc0 . We show now that this situation is impossible and that therefore Lmix is in L(GMIX ).

z and y do not introduce possible blocking indices (i. if indices are introduced. The tests were performed on the strings of length 6 and 9. Formally: S ⇒ #uS ⇒ #uwS ⇒ #uwxS ⇒ #uwxzS ⇒ #uwxzy Therefore for the following combination: ¯ ¯ ¯ ¯ ti utj wti xti z tj y tj : the following derivation is possible.3 GILs and Dyck Languages We argue in this section that GILs correspond to the result of the “combination” of a CFG with a Dyck language. GLOBAL INDEX GRAMMARS Assume the possible empty strings u. This assumption is made based on the previous two claims. etc. ¯ ¯ ¯ ¯ S ⇒ i#uti S ⇒ #uti S ti S ti S ⇒ j#uti vtj ti S ti S ⇒ ¯ ¯ ¯ ¯ ¯ ¯ ∗ ¯ ¯ ¯ ¯ j#uti vtj ti xti S ⇒ #uti vtj ti xti S tj S tj ⇒ #uti vtj ti xti z tj y tj Similar alternatives are possible for the remaining combinations: ¯ ¯ ¯ ¯ uti v ti wtj xti z tj y tj ¯ ¯ ¯ ¯ uti vtj wtj xti z tj y ti ¯ ¯ ¯ ¯ uti vtj wti xtj z tj y ti ¯ ¯ ¯ ¯ uti v ti wtj xtj z ti y tj ¯ ¯ ¯ ¯ uti vtj wtj xti z ti y tj ¯ ¯ ¯ ¯ uti vtj wti xtj z ti y tj ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ However the last one requires some additional explanation.) It can be seen that there is an alternative derivation: S ⇒ k#uai vS ⇒ #uai vbj Scj S ⇒ j#uai vbj wbi xcj S ⇒ #uai vbj wbi xcj Sci Saj ⇒ #uai vbj wbi xcj zci yaj . 3. they are also removed in the derivation of the substring). x. shows that any CFG is u . Therefore we conclude that there is no possible blocking eﬀect and there is always a derivation: S ⇒ #uawbycz ∗ ∗ ∗ ∗ We also used the generate-and-test strategy to verify the correctness of the above grammar Gmix for Lmix and two other grammars for the same language. Let us assume the ti triple corresponds to a(bc) and tj triple corresponds to b(ca) therefore it is: uai vbj wbi xcj zci yaj (or uai vbj ci xcj zbi yaj . The well-known Chomsky-Sch¨tzenberger theorem [22].e. given we are considering just two possible conﬂicting indices. w.32 CHAPTER 3.

Dyck languages can also provide a representation of GILs.3. This “combination” is formally deﬁned in the CFG case as follows: each context-free language L is of the form. GILS AND DYCK LANGUAGES 33 the result of the “combination” of a Regular Language with a Dyck Language. P 1) such that P1 is given according to the following conditions. if i ∈ I. R is a regular set and φ is a homomorphism [39]. where G = (N T. if p = A → αaβ then p1 = A1 → α1 a¯β 1 a 2. GILs can be represented using a natural extension of Chomsky-Sch¨tzenberger u theorem (we will follow the notation used in [39]). A GIG is the “combination” of a CFG with a Dyck language: GIGs are CFG-like productions that may have an associated stack of indices. As we have seen above. T and I are pairwise disjoint and |T ∪ I| = r ¯ ¯ The alphabet for the semi-Dyck set will be Σ0 = (T ∪ I) ∪ (T ∪ I). S. u For each GIL L. Deﬁne a CFG grammar G1 = (N. . This stack of indices. Theorem 1 (Chomsky-Sch¨ tzenberger for GILs) . where D is a semi-Dyck set. GILs include languages that are not context free. Σ0 . Proof Let L = L(G). i ∈ I. φ(¯) = a φ(i) = . which results in a PDA. if p = A → α then p1 = A1 → iα1 i 3 We 3 use a subscript 1 to make clear that either productions and non-terminals with such subscript belong to the CFG G1 and not to the source GIG. as we said. a CFL and a homomorphism φ such that L = φ(Dr ∩CF L). φ(¯ = i) if a ∈ T .3. T. I. there is an integer r. For every production p ∈ P where a ∈ T. and α. The analogy in the automaton model is the combination of a Finite State Automaton with a stack. has the power to compute the Dyck language of the vocabulary of indices relative to their derivation order. P ). such that α1 and β 1 ∈ (N ∪ T T )∗ as follows: 1. Deﬁne φ as the homomorphism from Σ0 ∗ into T ∗ determined by φ(a) = a. S 1 . #. β ∈ (N ∪ T )∗ create a new ¯ production p1 ∈ P 1. Push and pop moves of the stack have the power to compute a Dyck language using the stack symbols. Let Dr be the semi-Dyck set over Σ0 . L = φ(Dr ∩ R).

(2) and (3) i k n−1 n i n n−1 n−1 by Induction Hypothesis and (1) S ⇒ u A1 ⇒ u ia¯B 1 ⇒ u ia¯zC 1 ⇒ u ia¯z¯ a a a a ia¯ If u . so we have deﬁned Dr . φ and the corresponding CFL. Suppose w ∈ L. z ∈ Dr so is u ia¯z¯ a. We have to show that L = φ(Dr ∩ L(G1)). so is za¯. Suppose that if there is a GIL derivation δ#uA ⇒ δ#uyB (where u. Basis a) w = then #S ⇒ # and S 1 ⇒ b) |w| = 1 then #S ⇒ #a and S 1 ⇒ a¯ a Both and a¯ are in Dr ∩ L(G1) a The induction hypothesis exploits the fact that any computation starting at a given conﬁguration of the index stack and returning to that initial conﬁguration is computing a Dyck language. And if φ(z) = y then φ(za¯) = ya a a Case (B) If: #S ⇒ #uA ⇒ i#uaB ⇒ i#uayC ⇒ #uaya by Induction Hypothesis. Induction Hypothesis. The proof is an induction on the length of the computation sequence. First direction L ⊆ φ(Dr ∩ L(G1)). GLOBAL INDEX GRAMMARS 4. y ∈ k ¯ ¯ T ∗ ) implies there is a L(G1) derivation u A ⇒ u zB (where u . Basis: a) w = then S 1 ⇒ and #S ⇒ # k k n−1 b) |w| = 1 then S 1 ⇒ a¯ and #S ⇒ #a and φ(a¯) = a a a Induction Hypothesis Suppose that if there is a CFL derivation uA ⇒ uzB and z ∈ Dr then there is a GIL derivation δ#u ⇒ δ#u yA such that φ(z) = y Case (A) If: S 1 ⇒ zA1 ⇒ za¯ then a n−1 k . And if φ(z) = y and φ(u ) = u then φ(u ia¯z¯ a) = uaza a ia¯ a ia¯ The reverse direction φ(Dr ∩ L(G1)) ⊆ L. n > 1 then: Case (A) If: #S ⇒ #yB ⇒ #ya S 1 ⇒ zA1 ⇒ za¯ a It is clear that if z ∈ Dr . z ∈ (T T ∪ I ∪ I)∗ ) such that z ∈ Dr k and φ(z) = y for every k < n. Suppose w ∈ φ(Dr ∩ L(G1)). if p = A → α then p1 = A1 → ¯ 1 ¯ i CHAPTER 3.34 iα 3. if p = A → α then p1 = A1 → ¯ 1 iiα [i] L(G1) is a CFL.

#. S → S a ¯ i 7. Theorem 2 If L is a GIL. EQUIVALENCE OF GIGS AND LR-2PDA #S ⇒ #yA ⇒ #ya If z ∈ Dr so is za¯a¯ and if φ(z) = y then φ(za¯a¯) = yaa a a a a Case (B) If: S 1 ⇒ u A1 ⇒ u ia¯B 1 ⇒ u ia¯zC 1 ⇒ u ia¯z¯ a then a a a ia¯ #S ⇒ #yA ⇒ i#yaB ⇒ i#uayC ⇒ #uaya i k n−1 k n−1 n−1 35 If u . S }. j} CF Lww = L(GwwD ). {a. ¯ j. S }. a. S →S a¯¯ ai 3. S → aS i 2. ¯ i We exemplify how the Chomsky-Sch¨tzenberger equivalence of GIGs can be obtained constructu ing the grammar for the language L1: Example 13 () L(Gww ) = {ww |w ∈ {a. This is on our view a consequence of the fact that GIGs are a natural extension of CFGs.3. j}. b}∪I = {i. j} ¯ b. S → S ¯ a ia¯ 5. ¯ = Σ∪Σ. j}. S →S b¯¯ bj 4. a. ¯ S. S → bS j 3. z ∈ Dr so is u ia¯z¯ a and if φ(z) = y and φ(u ) = u then φ(u ia¯z¯ a) = uaza a ia¯ a ia¯ If other (possible) derivations were applied to u ia¯zC then the corresponding string would not a be in Dr . S → a¯iS a 6. b}. S. 2. .4. and we construct GwwD from Gww as follows: GwwD = ({S. then there exists a LR-2PDA M such that L= L(M). i. The proof is an extension of the equivalence proof between CFGs and PDAs. {i. ¯ i. #. ¯ i. S → 4. S → S b ¯ j ¯ Let D4 be the semi-Dyck set deﬁned over Σ0 = {a. S → S b¯¯ bj 1. b.4 Equivalence of GIGs and LR-2PDA In this section we show the equivalence of GIGs and LR-2PDA. P ) and P = ¯ b. i. S → b¯ bjS 7. b}∗ } Given Gww = ({S. S → S b ¯ j 6. b. S → 3. S → S a ¯ i 5. Σ = T = {a. ¯ j. {a. P ) and P = 1.

. The general description of the algorithm is as follows. Γ. S⊥. . Place the marker symbol ⊥ and the start variable on the stack. δ. )} Now we have to prove that L(G) = L(M). w. ⊥. I. . Given a GIG G: 1. )| where A → w is a rule in P } 3. if #S ⇒ #xα if and only if (q1.e. T. Repeat the following steps forever. . w. ) = {(q 1 . If the top of the stack is a variable A. j) = {(q 1 . Therefore each sentential must be of the form xα where x ∈ T and alpha ∈ V ∪ T Claim 5 #S ⇒ #xα iﬀ (q1. the only change that we require is to take into account the operations on the indices stated in the grammar rules. j)| where A → w is a rule in P } [j] 4. T. ⊥) where δ 1 . α. A. δ 2 = ∗ δ2 δ1 (q1. . i. Construct the LR-2PDA M = ({q 0 . S. We use as a basis the algorithm used in [77] to convert a CFG into an equivalent PDA. . GLOBAL INDEX GRAMMARS Proof Assume a GIG G that generates L. a. a. A. ⊥)} 2. ) = {(q 1 . )| where A → w is a rule in P } ¯ j 6. δ(q 1 . ⊥) ∗ Notice that the proof is trivial if all the derivations are context free equivalent. δ 2 = ⊥ . 2. q 1 . q 2 ) where Γ = V ∪ T ∪ I and δ: 1. δ(q 1 . compare it to the next symbol in the input. A. b. ) = {(q 1 . A. u) = {(q 1 . If the top of the stack is ⊥ accept. j) = {(q 1 . c. w. δ(q 0 . select one of the rules for A and substitute A by the string on the right-hand side of the rule. P ) be a GIG. ju)| where A → aw is a rule in P } j 5. S. q 2 }. . #. If they match repeat. q 0 . α. S. δ(q 1 . ⊥) or δ = [#]. If the top of the stack is a terminal a. . The corresponding formalization is: Let G = (V. δ(q 1 . a. a. ⊥) ∗ ∗ (q1. Remember GIGs require leftmost derivations for the rules that aﬀect the stack to apply. δ(q 1 . use G to construct an equivalent LR-2PDA. Otherwise reject this branch of the non-determinism. w. and aﬀect the second stack accordingly. x. x.36 CHAPTER 3.

⊥) k−1 (q 1 . . ⊥) k≥1 Case A context free If #S ⇒ δ#yAγ ⇒ δ#yaηγ = δ#xα where x = ya and α = ηγ then by IH and 2 or 3: (q 1 . . ⊥) Case B Push #S ⇒ µ#yAγ ⇒ jµ#yaηγ = jµ#xα then by IH and 4. ⊥. S. ι Given the last step implies β = Aγ for some A ∈ V .) or (2. Assume (q1. (q 1 . δ) for any (q 1 . the corresponding equivalence holds. ⊥) Case C Pop #S ⇒ jδ#yAγ ⇒ δ#yaηγ = δ#xα then by IH and 5. ⊥) k−1 and α = ηγ Hence: (q 1 . (q 1 . ya. δ) .) respectively. S. δ). ¯ j ∗ j k−1 ∗ ∗ k k ∗ (q 1 . that the claim above is a particular case of: #S ⇒ δ#xα iﬀ (q1. a. ηγ. ya. S. jµ) where δ = jµ. α. δ) (q 1 . a. ya. S. α. β. S. By (1. a. δ) implies #S ⇒ δ#yβ for any k ≥ 1 and show by induction on k that #S ⇒ δ#xα Let x = ya Case A. S.3. i. S. A → aη ∈ P where ι = #S ⇒ δ#yβ ⇒ yaηγ = xα Case B. ⊥) ∗ k−1 (q 1 . ∗ ¯ j The last step implies A → aη ∈ P Hence: #S ⇒ jδ#yβ ⇒ δ#yaηγ = xα The only if direction: Suppose that #S → δ#wα implies that (q 1 . . x. (q 1 . EQUIVALENCE OF GIGS AND LR-2PDA 37 This holds true by the equivalence of PDA and CFG. . . α. β. w. This case is a standard CFL derivation. ya. Pop moves in the auxiliary stack. δ) (q 1 . δ) (q 1 .e. jδ) ¯ j ¯ j (q 1 . a. (q 1 .4. ya. α. The last step implies A → aη ∈ P Hence: #S ⇒ γ#yβ ⇒ jγ#yaηγ = xα j ∗ Case C. Push moves in the auxiliary stack. ⊥) or δ = [#]. Aγ. a. jγ) where δ = jγ. . . x. x. µ) j (q 1 . β. α. α. Therefore we need to prove that whenever the stacks are used. . ⊥) First direction (if) Basis: #S ⇒ #x if (q1. Aγ. . k ∗ ∗ ∗ (q1. γ) j j (q 1 . α. ⊥) where x ∈ T ∪ { } and δ = (q1. S. S. δ) Induction Hypothesis. ⊥) ∗ (q1.

⊥) Theorem 3 If L is recognized by a LR-2PDA M. a.. i) contains (q 1 . A.. B n−1 in Γ and i. then the production is [qAq 1 ] → a. a. A. B 1 B 2 .. ).[q n−1 B n−1 q n ] such that δ(q. δ. the only modiﬁcation is to mimic the operation of the auxiliary stack. Assume Γ is composed of two disjoint subsets Γ1 . a. This construction is deﬁned so that a leftmost derivation in G of a string w is a simulation of the LR-2PDA M when processing the input w. with the stack of indices in the grammar.. Σ. w. Notice that in case 4. B 1 B 2 . B 1 . ). q n in Q. ⊥) step ≤ k − 1) we obtain #S ⇒ δ#xα = #x iﬀ (q 1 . j in I. j) contains (q 1 .. δ) = (q 1 .B n−1 .B n−1 . I = Γ2 . and 4. Proof Given a LR-2PDA construct an equivalent GIG as follows.B n−1 . [qAq n ] → a [q 1 B 1 q 2 ] [q 2 B 2 q 3 ] . α. α = (which excludes Case B Push to be the last step or move but not as a (q 1 . [qAq n ] → a [q 1 B 1 q 2 ] [q 2 B 2 q 3 ] . and P is the set of productions. q 1 .[q n−1 B n−1 q n ] such that [j] δ(q. B 2 . ⊥. i. P ) where V is the set of variables of the form qAp.[q n−1 B n−1 q n ] (pop) such that ¯ j δ(q. #. a must be in δ Σ.. F ). We follow the proof from [41]. ) contains (q 1 . GLOBAL INDEX GRAMMARS (q 1 .. I. Let G be a GIG = (V. δ) Given the values δ. (push) 5. 4. α. A.. [qAq n ] → a [q 1 B 1 q 2 ] [q 2 B 2 q 3 ] . ya. j)... In all the cases if n = 1. This conversion algorithm to construct a CFG from a PDA follows the one in [41] (including the notation).. A.. Aγ. .38 (q 1 . plus the new symbol S. x. ⊥. proving by induction on the steps in a derivation of G or moves of M that: #[qAp] ⇒ #w if and only if (q. q and p in Q. Γ2 . . S → q 0 ⊥q for each q in Q And for each q. A.. a.. ji). jδ) ∗ ¯ j (q 1 . then L is a GIL. 1. We need to show that L(G) = L(M ).. B 1 B 2 .. S. S.e.. A in Γ.. Σ. S.. such that Γ1 is used in the main stack and Γ2 is used in the auxiliary stack. ⊥) ∗ ∗ (p. Γ.B n−1 . . [qAq n ] → a [q 1 B 1 q 2 ] [q 2 B 2 q 3 ] . q 2 . j) contains (q 1 . ⊥) k−1 CHAPTER 3. q 0 . items 3. a. and cannot be given the constraints imposed on the possible transitions in a LR-2PDA. 3. each a in Σ ∪ { }. Let M be the LR-2PDA (Q. ⊥. A.[q n−1 B n−1 q n ] such that j δ(q. ⊥) . . 2. B 1 B 2 . .

y m = #w The same holds for the last symbol that is extracted from the stack (from II again): III. γ k ) implies: δ #[qAq n ] ⇒ γ k −1 #ay 1 y 2 . A. A.. y = y 1 .. these are a CFG and a PDA and therefore follows from the standard CFG.y m where each y i has the eﬀect of popping B i from the stack (see the details corresponding to the PDA-CFG case in [41]) then there exist states q 2 . B m . w.. A. ⊥. γ k −1 = j ∈ I and δ = ¯ j Now the “only if” part (the basis was proven above). y m . the induction hypothesis states that whenever the LR-2PDA M recognizes a string emptying the main stack and changing the auxiliary stack from a string of indices γ 1 to a string of indices γ k . . q m + 1 = p.. γ 1 ) k (p. ⊥) δ ∗ (q i+1 ..[q n−1 B n−1 q n ] where δ can be only be some j in I then γ 1 = j or δ is [⊥]. ⊥.B m . B i .. A. γ k −1 = ⊥ and δ = or [#] or 2.3. ⊥. In other words. y. ay. . w ∈ Σ∗ . ie. γ 1 ) k−1 (p. ⊥) ∗ k−1 ∗ (q n−1 .. ay. PDA equivalence. ... γ k ) for any k ≥ 1. Therefore I.. γ k −1 ) (p. γ i+1 ) then γ i #[q i B i q i+1 ] ⇒ γ i+1 #y i ∗ (q 1 . w. given the only type of rules/moves applicable are 1 and 2 (in this case where δ = [⊥]). where γ i ∈ I ∗ and ∗ u.: (q.B m .. such that the inductive hypothesis holds for each: II. y. .. then either 1. (q. implies: #[qAq n ] ⇒ γ 1 #a[q 1 B 1 q 2 ] [q 2 B 2 q 3 ] ... A. First (if) direction: Induction Hypothesis: If (q.[q n−1 B n−1 q n ] ⇒ γ k #ay 1 y 2 . γ i ) for 1 ≤ j ≤ m The ﬁrst move in I. y i .4.... ..y m−1 [q n−1 B n−1 q n ] ⇒ γ k #ay 1 y 2 .. (q i . γ k ) Decomposing y in m substrings. (q. γ 1 ) implies #[qAq n ] ⇒ γ 1 #a [q 1 B 1 q 2 ] [q 2 B 2 q 3 ] . The basis is also proven for both directions.. B 1 B 2 . so the induction hypothesis is: If γ 1 #u[qAp] ⇒ γ k #uw then (q. γ k ) then γ 1 #u[qAp] ⇒ γ k #uw. ⊥) (q 1 . . ⊥. q m +1.. in k moves (for any k ≥ 1) then the GIG G will derive the same string w and string of indices γ k I.y m = #w where γ k = ⊥. B 1 B 2 . EQUIVALENCE OF GIGS AND LR-2PDA 39 If only rules created with step 1 or 2 and the corresponding transitions are used then. γ 1 ) Suppose: k ∗ (p. ay. . then γ 1 = .

γ k − 1) (q n .. γ k ) where the possibilities are either xm = xn or δ = [⊥] or and given we require γ k to be ⊥ then the only possibilities are: (A) either γ k = γ k −1 = ⊥ and δ = (B) δ = γ k −1 then γ k = ⊥ ¯ The ﬁnal observation is that we satisfy the ﬁrst claim assigning the following values: q = q O and A = Z 0 .. A.... γ i+1 ) for 1 ≤ i ≤ n Now we can add B i+1 .. A. . ⊥.. ∗ where γ 1 is ⊥ if δ in the ﬁrst step of I.xm [q n−1 B n−1 q n ] ⇒ γ k #uw which in turn implies: δ (q.[q n−1 B n−1 q n ] ⇒ γ k #uw δ k−1 where q n = p. w..40 CHAPTER 3. ⊥) or xm = (q n−1 . xm .xn ): (q. is If we consider the last step from I. γ i ) ∗ ∗ (q i+1 .. B 1 B 2 . Again. B i+1 .. ⊥. γ k ) #u[qAq n ] ⇒ γ k −1 #uax1 . we obtain (remember w = ax1 x2 . γ i ) ∗ (q i+1 . B i . ⊥). B n . Z 0 ) ∗ ∗ (p. ⊥) k−1 ∗ (p. ⊥. w. B i B i+1 ..: and from this move and II. where i = 1.. we obtain: #S ⇒ #w iﬀ (q 0 ..xn . xi . w. . ..B n . γ i+1 ) From the ﬁrst step of the derivation in I. x1 x2 . So according to 1. . #u[qAq n ] ⇒ γ 1 #ua [q 1 B 1 q 2 ] [q 2 B 2 q 3 ] . xi .. . A.. then (q.n...B n to each stack in the sequence of ID’s so that: II. w..B n . (q i . in the construction of the GIG G. 2. we can decompose w as ax1 x2 . GLOBAL INDEX GRAMMARS I. γ 1 ) or [⊥].B n . . . ⊥) (q 1 ..xn such that γ i #ui [q i B i q i+1 ] ⇒ γ i+1 #ui xi therefore by the induction hypothesis: (q i .. ⊥.

Therefore a LBA can simulate a LR-2PDA. the relation to LILs is interesting because of their similarities both in the grammar and the automaton model. corresponds to an amount of tape equal to the input in a LBA. However GCSLs might include trGILs. Due to the constraints on the push productions at most the same amount of symbols as the size of the input can be introduced in the additional stack. We do not address possible relationship with the counter languages [42] however. and the constraints imposed on the use of the additional stack in the GIL automaton might be seen as a shrinking property. GILs might include LILs and perhaps LCFRLs. The additional stack in GIGs/LR-2PDA. another family of languages that has some similarities with GILs. • Proper inclusion of GILs in CSLs. Moreover. The relation to Growing Context Sensitive languages is interesting for a similar reason. 41 . The corresponding automaton is another two stack machine. GILs and ILs might be incomparable. GILs are incomparable to the Growing Context Sensitive Languages (GCSLs).1 Relations to other families of languages There are two clear cut relations that place GILs between CFLs and CSLs: GILs are included in CSLs and GILs include CFLs.Chapter 4 Global Index Languages Properties 4. Most of other relations are more diﬃcult to determine. It is interesting to establish the relation of GILs to LILs and LCFRLs because there is an extensive tradition that relates these families of languages to natural language phenomena.

This can be proved using the same type of construction as in the CFL case (e. P 1 . ∗ . We consider this quite possible. using two GIG grammars. I 2 . ILs are not semi-linear and GILs are semi-linear. GCSLs include the language {ba2 |n ≥ 1} which is not semi-linear. Construct the grammar G3 = (N 1 ∪ N 2 . I 1 . #. S 2 ) Since we may rename variables at will without changing the language generated. S 1 ) and G2 = (N 2 . P 3 . A string w is in L1 if and only if the derivation #S 3 ⇒ #S 1 ⇒ #w is a derivation in G3 .g. such as the MIX language. Assume also that S 3 . This is an open question. GILs contain some languages that might not be ILs. T 1 ∪ T 2 . Proof Let L1 and L2 be GILs generated respectively by the following GIGs: G1 = (N 1 . S 4 . Union L1 ∪ L2 :. • CFLs are properly included in GILs.2 Closure Properties of GILs The family of GILs is an Abstract Family of Languages. care should be taken that the two sets of stack indices be disjoint. For concatenation. P 2 . However it remains as an open question. concatenation and Kleene closure. S 3 ) where P 3 is P 1 ∪ P 2 plus the productions S 3 → S 1 | S 2 . [41]). This result is obtained from the deﬁnition of GIGs. • Proper inclusion of LILs in GILs. T 2 . There are no other derivations from S 3 than #S 3 ⇒ #S 1 and #S 3 ⇒ #S 2 Therefore L1 ∪ L2 = L3 . T 1 . we assume that N 1 . The copy language {ww|w ∈ Σ∗ } is not a GCSL [53]. Proposition 1 GILs are closed under: union. instead of two CFG grammars. I 1 . • GILs and Growing Context Sensitive Languages are incomparable. n 4. #. The same argument holds for w in L2 starting the derivation #S 3 ⇒ #S 2 . N 2 . #.42 CHAPTER 4. I 2 are disjoint. I 1 ∪ I 2 . GLOBAL INDEX LANGUAGES PROPERTIES • Proper inclusion of GILs in ILs. S 5 are not in N 1 or N 2 . We discuss this issue in Chapter 6.

and a string u is in L2 if and only if the derivation #wS 2 ⇒ #wu. (b) the terminals of G1 are the terminals of the substituting grammars Ga . Proposition 2 GILs are closed under substitution by -free CFLs. (e) The productions of G1 are all the productions of each Ga together with all the productions from G modiﬁed as follows: replace each instance of a terminal a in each production by the start symbol of Ga . S 4 ) such that P 4 is P 1 ∪ P 2 plus the production S 4 → S 1 S 2 . is a derivation in G4 for some w. P 5 . -free regular sets. T 1 ∪ T 2 . Notice that #S 4 ⇒ #S 1 ⇒ δ#wS 2 for some δ in I 1 does not produce any further derivation because the I 1 and I 2 are disjoint sets. where each Ga is in GNF. Let L be L(G) and for each a in Σ let La be L(Ga ). #. CLOSURE PROPERTIES OF GILS 43 Concatenation:.Let G5 = (N 1 ∪ {S 5 }. Construct a GIG grammar G1 such that: (a) the non terminals of G1 are all the non-terminals of G and of each Ga . I 1 ∪ I 2 . Proof Let L be a GIL. This proof adapts the substitution closure algorithm given in [41] to prove substitution closure by CFLs. [#] ∗ ∗ ∗ The proof is similar to the previous one. and for each a in Σ let La be a CFL. Assume that the non-terminals of G an Ga are disjoint. Closure:. The proof that L(G4 ) = L(G1 )L(G2 ) is similar to the previous one. #. A string w is in L1 if and only if the derivation #S 4 ⇒ #S 1 ⇒ #wS 2 is a derivation in G4 . P 4 . L ⊆ Σ∗ .2. S 1 ) where P 5 is P 1 plus the productions: S5 → S1 S5 | . I 1 . The substituting CFG must be in Greibach Normal Form (so as to respect the constraints on productions that push indices in the stack). (c) the set of indices I and # are the set of indices and # from G (d) the start symbol of G1 is the start symbol of G. Construct G4 = (N 1 ∪ N 2 . given the only production that uses S 1 and S 2 is S 4 L(G4 ) = L1 · L2 .4. T 1 . -free homomorphisms. therefore also no δ ∈ I 2 can be generated at this position.

Y ) contains ([p . ⊥) (q. a. γ. Σ. a. η). q ]. Construct an LR-2PDA M 1 accepting h−1 (L) in the following way. q 0 ].44 CHAPTER 4. q 0 . δ A . a) = p and δ G (q. F ). On input a M 1 generates the string h(a) stores it in a buﬀer and simulates M on h(a). Let L = L(M ) where M is the LR-2PDA (Q. Γ. w. q 0 ]. GLOBAL INDEX LANGUAGES PROPERTIES Note that the requirement that the substituting grammar be in GNF implies that it is an -free CFL. Proof Let L be L(M ) for an LR-2PDA M =(QG . q]. p0 . δ. . w. ⊥. Z. Σ. η) if and only if (an induction proof is given by [41] for the CFL case) (q 0 . in which case p = p and η = i or η = Y It is easy to see that ([p0 . X. a similar proof to that used in the CFL case works for these closure properties: in both cases a LR-2PDA with a modiﬁed control state is used (again see [41] for the CFL case). γ. ⊥) ([p. γ. Proposition 3 If L is a Global Index Language and R is a regular set. q]. η) if and only if: δ A (p. Σ. . X. F G ) and let R be L(A) for a DFA A = (QA . L ∩ R is a Global Index Language. Construct M’ = (QA ×QG . w) = p i Proposition 4 Global Index Languages are closed under inverse homomorphism. ⊥. Therefore L(M 1) = {w | h(w) ∈ L}. γ. Parikh [60] showed that CFLs are semilinear. F A ). η) and δ(p0 . [p0 . Σ. Proof Let h : Σ → ∆ be a homomorphism and let L be a GIL. ⊥. GILs are also closed under intersection with regular languages and inverse homomorphism. GILs do not tolerate an substitution due to the constraints on type b. Note that a may be . Y ) contains (q . q 0 . 4. . δ. Γ.3 Semilinearity of GILs and the Constant Growth property The property of semilinearity in a language requires that the number of occurrences of each symbol in any string (also called the commutative or Parikh image of a language) to be a linear combination of the number of occurrences in some ﬁnite set of strings. F A ×F G ) such that δ is deﬁned as follows: δ([p. Γ. Again. δ G . (push) productions which require Greibach normal form.

6.. is semilinear provided that the languages corresponding to C are semilinear. L2 in Σ∗ are letter-equivalent if ψ(L1 ) = ψ(L2 )... 35]). [55. where M c is obtained from an automata class C by augmenting it with ﬁnitely many reversal-bounded counters. We follow the proof presented in [37] to prove that the class of languages L(M c ). [46. Roughly speaking. Deﬁnition 9 Parikh Mapping (see [39]) : Let Σ be {a1 . then their intersection X ∩Y is also semilinear.. ψ(L) = {ψ(w)|w ∈ L}. Deﬁnition 8 A set V in Nn a) is linear if V = {v 0 + c1 v 1 + .e. Semilinearity has been assumed as a good formulation of the constant growth property of natural languages (e.3. The commutative or Parikh image of a language L ∈ Σ∗ . Intuitively. Two languages L1 . We will use the following lemma in the proof of semilinearity for GIGs. The Parikh image of a language is the set of all vectors obtained from this mapping to every string in the language. 37]). 60]. This property has been extensively used as a tool to characterize formal languages (e.. concept. deﬁne a mapping from Σ∗ into N n as follows: ψ(w) = (|a1 |(w). 86]). We will not discuss here whether semilinearity is the correct approach to formalize constant growth.. Lemma 4 If X and Y are semilinear subsets of Nn . the constant growth property requires that there should be no big gaps in the growth of the strings in the languages. v i ∈ Nn for 1 ≤ i ≤ m} b) is semilinear if V is the ﬁnite union of linear sets. the property of semi-linearity of GILs follows from the properties of the control mechanism that GILs use. SEMILINEARITY OF GILS AND THE CONSTANT GROWTH PROPERTY 45 i.4.g.g. We assume a deﬁnition of semilinearity of languages such as that found in [39. If ψ(L) is semi-linear. The Parikh mapping is a function that counts the number of occurrences in every word of each letter from an ordered alphabet. . as Theorem 5. The proof of this lemma is in [30]. . Theorem 5 If L is a GIL then L is a semi-linear language. that CFLs are letter-equivalent to a regular set.. .. L is a semi-linear language. recently it has been claimed that semilinearity might be too strong a requirement for models of natural language (e.1. an }. [33. + cm v m |ci ∈ N.g. However. |an |(w)) where |ai |(w) denotes the number of occurrences of ai in w.

This follows from Theorem 1. GLOBAL INDEX LANGUAGES PROPERTIES The proof exploits the properties of Theorem 1: every GIL L = φ(Dr ∩ L1) such that L1 is a CFL. in . I. 4. We can consider pumping lemmas for diﬀerent families of languages as specifying the following facts about them: . and α. note that S 2 is a subset of S 1 .. if p = A → α then p1 = A → α 2. ψ(L(G1)) is an eﬀectively computable semi-linear set S 1 . S. ik . P ) such that ¯ Σ1 is (Σ ∪ I ∪ I) and P 1 is given according to the following conditions. if p = A → α then p1 = A → ¯ iiα [i] It can be seen that L(G1) ⊆ Σ1 ∗ and that for each w that is in the GIL L(G) there is a word w1 ∈ L(G1) such that |i|(w1) = |¯ i|(w1)... For every production p ∈ P where a ∈ T. From S3 we obtain S 0 the semilinear set corresponding to ψ(L(G)). By the Parikh theorem [60] the Parikh map of the CFL L(G1). removing the illegal derivations. removing the pairs of ik and ¯k coordinates. i ∈ I. ip . Let S 2 be the semilinear set {(a1 . if p = A → α then p1 = A → ¯ iα ¯ i 4. .46 CHAPTER 4. #. Proof Given a GIG G = (N. Computing the intersection of S 1 and S 2 amounts to compute the properties that the control performed by the additional stack provides to GILs. Σ. P 1) Deﬁne a CFG grammar G1 = (N. as follows: 1. i Corollary 6 The emptiness problem is decidable for GILs. The intersection of S 1 and S 2 is a computable semilinear set S 3 according to [30]. in other words. ¯k ∈ N} where the pairs of ik and ¯k i i i i ¯ coordinates correspond to symbols in I and the corresponding element in I. ∈ (N ∪ T )∗ create a new production p1 ∈ P 1. ¯n . Dr and L1 are semilinear by the Parikh theorem (L1 and Dr are CFLs)..4 Pumping Lemmas and GILs This section and the remainder of this chapter will present some exploratory ideas rather than established results. We modify the construction of L1 in the proof of Theorem 1. ¯p )|aj . Σ1 .. am . S.. if p = A → α then p1 = A → iα i 3.

4.4. PUMPING LEMMAS AND GILS

47

• Regular Languages: Inserting any number of copies of some substring in a string always gives a regular set. • Context Free Languages: every string contains 2 substrings that can be repeated the same number of times as much as you like. • GCFLs, LCFRLs, others and GILs, there is always a number of substrings that can be repeated as many times as you like. Following upon this last observation, the following deﬁnition is given in [35] as a more adequate candidate to express properties of natural language. This is a candidate for a pumping lemma for GILs. Deﬁnition 10 (Finite Pumpability) . Let L be a language. Then L is ﬁnitely pumpable if there is a constant c0 such that for any w ∈ L with |w| > c0 , there are a ﬁnite number k and strings u0 , ..., uk and v 1 , ..., v k such that w = u0 v 1 u1 v 2 u2 ...uk −1 v k uk and for each i, 1 ≤ |v i | < c0 and for any p ≥ 0, u0 v 1 p u1 v 2 p u2 ...uk −1 v k p uk ∈ L. Compare the previous deﬁnition with the following k-pumpability property of LCFRS ([71], and also in [35]) which applies to any level-k language. Deﬁnition 11 (k-pumpability) Let L be a language. Then L is (universally) k − pumpable if there are constants c0 ,k such that for any w ∈ L with |w| > c0 , there are stringsu0 , · · · , uk and v 1 , · · · , v k such that u0 v 1 u1 v 2 u2 · · · uk −1 v k uk , for each i : 1 ≤ |v i | < c0 , and for any u0 v 1 p u1 v 2 p u2 ...uk −1 v k p uk ∈ L. In this case the k value is a constant determined by the k-level of the language.

4.4.1

GILs, ﬁnite turn CFGs and Ultralinear GILs

We showed that there is no boundary in the number of dependencies that can be described by a GIL (see the language Lm in the previous chapter). This fact and the candidate pumping lemma for GILs are related to the following observation. For any CFG that recognizes a number of pairs of dependencies, ( e.g., La = {an bn , cm dm |n ≥ 1, m ≥ 1} has 2 pairs of dependencies or turns [32, 39, 88, 5]) there is a GIG that generates the total number of dependencies included in the

48

CHAPTER 4. GLOBAL INDEX LANGUAGES PROPERTIES

pairs. This is done by “connecting” the CFG pairs of dependencies (turns) with “dependencies” (turns) introduced by the GIG extra stack. This “connection” is encoded in the productions of the corresponding terminals. For example, in La it is possible to “connect” the b’s and c’s, in a turn of the GIG stack: any production that has a b in the right-hand side also adds an index symbol to the GIG stack (our notation for this will be bx ), and every production that has a c in the right-hand side removes the same index symbol from the production stack (we will denote this by c¯ ). x La = {an bn cm dm |n ≥ 1, m ≥ 1} → Lb = {an bx n c¯ m dm |n ≥ 1, m ≥ 1} = {an bn cn dn |n ≥ 1, } x Conjecture 1 For any k-turn CFG, where k > 1 is ﬁnite, there is a GIG that generates a language with (2 · k) dependencies. These observations are also related to the fact that LIGs (and the equivalent automata), can connect one-turn for each stack [85]. Therefore the boundary of the number of dependencies is four.

4.5

Derivation order and Normal Form

We introduced GIGs as a type of control grammar, with leftmost derivation order as one of its characteristics. GIG derivations required leftmost derivation order. We did not address the issue of whether this is a normal form for unconstrained order in the derivation, or if an extension of GIGs with unconstrained order in the derivation would be more powerful than GIGs. In this section we will speculate about the possibility of alternative orders in the derivation, e.g. (rightmost) or free derivation order. The following grammar does not generate any language in either leftmost or rightmost derivation order: Example 14 L(G6 ) = {an bm cn dm }, where G6 = ({S, A, B, C, D}, {a, b, c, d}, {i, j}, S, #, P ) and P = 1. S → A B C D 6. C → cC

¯ i

2. A → aA

i

3. A → a

i ¯ j ¯ j

4. B → bB

j

5. B → b

j

7. C → c

¯ i

8. D → dD

9.D → d

The only derivation ordering is an interleaved one, for instance all the a’s are derived ﬁrst, then all the c’s, followed by the b’s and ﬁnally the d’s. However we know that such a language is a GIL. It is our belief that the following conjecture holds, though it might be diﬃcult to prove. Unrestricted derivation order would introduce only unnecessary additional ambiguity.

4.5. DERIVATION ORDER AND NORMAL FORM

49

Conjecture 2 Unrestricted order of the derivation in a GIG is not more powerful than leftmost derivation order. Following the previous example, the next example might seem impossible with leftmost/rightmost derivation. It looks like an example that might support the possibility that unrestricted order of the derivation might yield more powerful grammars. Example 15 L(G6b ) = {an bm cl dm en f l | n, m, n ≥ 1}, where G6b = ({S, A, B, C, D, E, F }, {a, b, c, d, e, f }, {i, j, k}, S, #, P ) and P is: 1. S → ABCDEF 5. B → b

j k

2. A → aA

i

3. A → a

i

4. B → bB

j

6. C → cC | c 10.E → e

¯ i

7. D → dD

¯ j

8.D → d

¯ j

9.E → eE

¯ i

11. F → f F

¯ k

12. F → f

¯ k

A derivation with unrestricted order would proceed as follows: S ⇒ ABCDEF ⇒ i#aABCDEF ⇒ ji#abCDEF ⇒ kji#abcDEF ⇒ ji#abcDEf ⇒ i#abcdEf ⇒ #abcdef However the following grammar generates the same language in leftmost derivation: Example 16 L(G6c = {an bm cl dm en f l | n, m, n ≥ 1}, where G6b = ({S, A, B, C, D, E, F }, {a, b, c, d, e, f }, {i, j, k}, S, #, P ) and P is: 1. S → A 5. B → bC

j

2. A → aA

i k

3. A → aB

i

4. B → bB

j

6. C → cCf | cM f 10.E → De

¯ i

M → DE

7. D → dD

¯ j

8.D → d

¯ j

9.E → Ee

¯ i

**Similarly the following language which contain unordered crossing dependencies is a GIL: {an bm cl dp bm an dp c l |n, m, l, p ≥ 1}
**

2 2 2 2

The next example also shows that leftmost and rightmost derivation ordering might produce two diﬀerent languages with the same grammar for each ordering, introducing therefore another dimension of ambiguity. Example 17 L(G7 ) = {ww|w ∈ {a, b}∗ } ∪ {wwR |w ∈ {a, b}∗ } derivation respectively) (in leftmost and rightmost

G7 = ({S, S , A, B}, {a, b}, {i, j}, S, #, P ) and P =

50 1. S → aS

i

**CHAPTER 4. GLOBAL INDEX LANGUAGES PROPERTIES 2. S → bS
**

j

3. S → S 8. A → a

¯ i

4. S → S A 9. B → b

¯ j

5. S → S B

6. S → A

7. S → B

**Rightmost derivation produces: #S → i#aS → ji#abS → ji#abS → ji#abS B → ji#abAB → i#abAb → #abab
**

i j ¯ j ¯ i

**Leftmost derivation produces: #S → i#aS → ji#abS → ji#abS → ji#abS A → ji#abBA → i#abbA → #abba
**

i j ¯ j ¯ i

It is a device for eﬃciently handling of nondeterminism in stack operations. jii#. 51 .) #. ji#. jjj#. the number of possible conﬁgurations would grow exponentially with the length of the input. For instance. j#.1 Graph-structured Stacks In this section we introduce the notion of a graph-structured stack [80] to compute the operations corresponding to the index operations in a GIG.1 If all the possible stack conﬁgurations in a GIG derivation were to be represented. in ﬁgure 5. iji#. This is a departure from Tomita’s graph-structured stack. etc. As an initial approach. jij#. j with maximum length of stack 3.Chapter 5 Recognition and Parsing of GILs 5. ii#. (i. ijj#.1. The set of nodes that represents the top of the stack will be called active nodes (following Tomita’s terminology). jj#. While the number of possible nodes increases. each node of the graph-structured stack will represent a unique index and a unique length of the stack. ij#. and [50] for an approach to statistical parsing using graph algorithms. The numbers indicate the length.e. the active nodes are represented by circles and the inactive are represented by squares. The one at the right is equivalent to the maximal combination of stack conﬁgurations for indices i. The graph-structured stack at the left represents the following possible stack conﬁgurations: iii#. i#. iii#. 1 See [51] for a similar approach to Tomita’s. the number of edges connecting a node to others is limited. Each node at length n can have an edge only to a node at length n − 1.

. 0] 2 For 0 ≤ i ≤ n do: Process each item s ∈ S1i in order performing one of the following: a) Predictor: (top-down prediction closure) .1 GILs Recognition using Earley Algorithm Earley Algorithm.1 $. 5. RECOGNITION AND PARSING OF GILS i.0 j.. Therefore the number of edges connecting a node to a preceding one is bound by the size of the indexing vocabulary. Push(newnode.ai . Earley’s main data structures are states or “items”..3 Figure 5. Pop(curretnode). S.an with n ≥ 0 any integer i such that 0 ≤ i ≤ n is a position in w. An item [A → α • β.1 j.2 i. given a string w = a1 a2 . Let G = (N.3 i. Create the Sets S i : 1 S0 = [S → • S$. and ai ∈ T for 1 ≤ i ≤ n.1: Two graph-structured stacks The following operations are possible on the graph-structured stack. Earley items are inserted in sets of states. pj ].. Because at this point we use nodes of unambiguous length. n ≥ 0. currentnode connects only to nodes of current length-1.3 i. P ) be a CFG.52 i. Therefore.2 i.oldnode). These items are used to represent intermediate steps in the recognition process. Earley’s parsing algorithm [27] computes a leftmost derivation using a combination of top-down prediction and bottom-up recognition.0 j. Let w = a1 a2 · · · an be an input string. T.3 CHAPTER 5. which are composed of a ”dotted” rule and a starting position: [A → α • β.2 j. Algorithm 1 (Earley Recognition for GFGs) .2 5. pj ] is inserted in the set of states S i if α corresponds to the recognition of the substring aj . There are as many sets as positions in the input string.2 j.1 $.1 j.2. Retrieves all the nodes that are connected by an edge from the currentnode. Creates a newnode if it is not in the graph and creates an edge from newnode to oldnode if necessary.

2. used to record the ordering of the rules aﬀecting the stack. and ai ∈ T for 1 ≤ i ≤ n. j] ∈ S i : for [A → α • Bβ. k] ∈ S j : add [A → αB • β. We use the graph-structured stack and we represent the stack nodes as pairs of indices and counters (the purpose of the counters is to keep track of the length of the stack for expository purposes). S. #. A → α • Aβ. a pointer to an active node in the graph-structured stack. O. Create the Sets S i : 1 S0 = [(#. such that O ≤ n where n is the length of the input. If [A → α • aβ. j] ∈ S i and (A → γ) ∈ P : add [A → • γ.{a. Let w = a1 a2 · · · an be an input string. If i = n and Sn+1 = {[S → S$ • . i] to S i b) Completer: (bottom-up recognition) If [B → γ • . and O. We modify Earley items adding two parameters: ∆. 0]} then accept 53 5. 0). 0] 2 For 0 ≤ i ≤ n do: Process each item s ∈ S i in order performing one of the following: a) Predictor b) Completer c) Scanner 2 Actually O ≤ 2n.{i}. P ) be a GIG. Initialize the graph-structured stack with the node (#.2 Therefore Earley items for GILs might be as follows: [∆. I. k] to S1i c) Scanner: equivalent to shift in a shift-reduce parser. j] to S i + 1 3 4 If S i+1 is empty.{P}) with P: S → aS | bS S→S| ¯ i . j] ∈ S i and wi + 1 = a: add [A → αa • β.5. 0).2. if pop rules “erase” symbols from the stack.b}. T. Reject. 0.2 First approach to an Earley Algorithm for GILs. n ≥ 0.{S}. An example of such case would be the following i grammar: Gd = ({S}. pj ] Algorithm 2 (Earley Recognition for GIGs) . Let G = (N.{#}. S → • S$. GILS RECOGNITION USING EARLEY ALGORITHM If [B → α • Aβ.

k] ∈ S j where δ 2 = i if µ = ¯ i: δ add [∆1 . A → αB • β.2 add every [(δ 2 . C 2 ). O. A → α • Bβ.54 3 4 If S i+1 is empty. C 2 = C 1 − 1 if δ = then (δ 1 . C 2 ) and O1 = O2 ( move) if δ = [δ 1 ] then (δ 1 . C 2 ) and O1 = O2 2. C 1 ) ) s. to perform the corresponding operations on the graph-structured stack. 1. j] ∈ S i : µ for [(δ 2 . Scanner If [∆. Completer A If [∆1 . and have the corresponding initial order in the derivation. A → • γ. 0). 0. (δ 1 . i] to S i δ such that: if δ ∈ I then δ 2 = δ. O1 . 0). C) such that C ≤ n. C 2 ). B → γ • . The example . Completer B If [∆1 . completer used in the For loop in 2 are modiﬁed as follows. O − 1. j] ∈ S i and wi + 1 = a: µ add [∆. C 2 ). j] ∈ S i and (A → γ) ∈ P : µ δ 1. C 1 )) s. The operations predictor. O2 = O1 + 1 and push( (δ 2 . k] to S i δ 3. Reject. O. As we said.t. O. k] ∈ S j where δ 2 = i if µ = [i]: add [∆1 . Predictor If [(δ 1 . j] to S i + 1 µ 3. O. A → αa • β. C 1 ). k] to S i δ The following example shows the trace of the items added to a chart parser implementing the above algorithm.t. scanner. A → αB • β. C 1 ) = (δ 2 . C 2 ) ∈ pop((δ 1 . 0]} then accept The structure of the main loop of Earley’s algorithm remains unchanged except for the require- ment that the initial item at S 0 (line 1) and the accepting item at S n + 1 (line 4) point to the empty stack node (#. C 1 ) = (δ 2 . we represent nodes in the graph-structured stack with pairs (δ. CHAPTER 5. B → α • Aβ. RECOGNITION AND PARSING OF GILS If i = n and Sn+1 = {[(#. O. B → γ • . A → α • aβ. O. O − 1. C 2 ). j] ∈ S i where µ = µ δ or µ = [i]: for [(δ 2 . A → α • Bβ. O2 . This implementation used Shieber’s deduction engine backbone [72]. S → S$ • . C 2 = C 1 + 1 if δ = ¯ and i = δ 1 then O2 = O1 + 1 and i (δ 2 .

il]. [Stacksymbol.0.4.1.B.(#.3) 16 Adding to chart: <23852> item(B.1.0.[].4) .Adding to chart: <27540> item(S.2) 13.[i.(i.[i.[S.c].[b]. #.2)]) 12 Adding to chart: <23725> item(B.[i.[#.[].1.[].2) 11.[#.1.3.[b. B}.[].2.[#.[]. StackOperation].d].3).c].[#. Example 18 (Trace of aabbccdd) L(G2 ) = {an bn cn dn |n ≥ 0}.[a.c].2. P.[#.[i.[a.[].0.[b].0. Adding to chart: <23851> item(B.3) 17.[].0) Adding to stack: <22605> item((i.[].[#. i S→B B → bBc ¯ i B → bc ¯ i 1 Adding to chart: <10898> item(<start>.0.[b. G2 = ({S.1) 9 Adding to chart: <10640> item(S.2.3.0. ﬁnalposition) The stack operation is represented as follows: “il” is a push rule of the stack index “i” and “ir” is a pop rule. {i}.1.1.3. Each item is represented as follows: item(LeftSymbol.d].1.3.0) 3 Adding to chart: <23470> item(S.1)) 7 Adding to chart: <23598> item(B.[b].Adding to chart: <23725> item(B.2) 14.1.2.1.[b. S).0) 2 Adding to chart: <27413> item(S.1) 6.2.2.[S.1) 8 Adding to chart: <23598> item(B.[c].[S].0.3) 15.d]. c.1.e].e].il].il].2.[a].[i.2.[i.[i.e].[a].2.[i.S.[b.[B].3.3.3. Adding to chart: <23852> item(B.[a.2) 10.[]. StackCounter.[B]. where P is: S → aSd.[#.[B.2.0.4. initialposition.1) 5.[i.1.[b.2) Adding to stack: <22863> item((i. OrderCounter.d].c].0.3.ir]. b.ir].[].2.[B].5.B.d].2).3) 18.2.2.[].[].c]. {a.(i.3.ir].e].ir].il]. Adding to chart: <27798> item(B.ir].Adding to chart: <23724> item(S.S.1.S.Adding to chart: <23599> item(S.[i.0. Adding to chart: <26897> item(B.1).Adding to chart: <27671> item(S.[i.0)) 4 Adding to chart: <10771> item(S.1) Adding to stack: <22732> item((i. GILS RECOGNITION USING EARLEY ALGORITHM 55 shows the recognition of the string aabbccdd with the grammar G2 transformed into a trGIG.il].[B.0.ir]. Predotlist.ir].c].0.ir]. Postdotlist.B.2.1.[b.[]. d}.ir].2.0.c].4.1.c].1.

0).2) aaS ⇒ (j .[#.[B].[d.[c]. j . 6.e]. the corresponding productions of the grammar Gww repeated below and the string aaba 1. 3] ∈ S 3 : ¯ j add [(#. S → aS i 2.1.il]. The pairs in parenthesis represent the nodes of the graph-structured stack: (#.[]. S → R • .[c. Adding to chart: <10883> item(S.0) S ⇒ (x.2) aaR⇒ (i. the following complete operation would be performed : Given [(#.0) S ⇒ (i. Adding to chart: <23342> item(S. aaRa ⇒ (?.[#.0.6) 25.3.2.0.7) 26.a].2.0. Adding to chart: <10625> item(S.0)aaba[a][b] ¯ i 6 After recognized this substring.b]. 2. Adding to chart: <27654> item(B. b}∗ }. the completer operation may jump up two steps and complete the “R” introduced after step 3. In the following example the square brackets represent substrings to be recognized. R → Ra | a ¯ i 5.3) aabR⇒(i.2.0. S → bS j 3. This bookkeeping is performed here by the order parameter.S.8) 28.0.1).[#.3.ir].S. 3).1.[c.0. Adding to chart: <10982> item(<start>. 3. S → R 4. 3] to S 4 Then the following are sequentially added to S 4 : a) [(#.[S].6) 23.[].2. 0).1)aabR[a][b]⇒(#.4. 3] ∈ S 4 and [(j.2) aaS ⇒(i.[b].e].1) aS ⇒ (i.[#. the following sequences can be generated using Earley’s Algorithm if no ordering constraint is enforced at the Completer Operation.0.b].4) 20.3.0.a]. instead of the one introduced at step 5.[d].1.B.[#.il].[].5) 21.6) 24.[#. RECOGNITION AND PARSING OF GILS Adding to chart: <22956> item(B.[S. S → bS • .[#. 2].56 19 CHAPTER 5.0. Adding to chart: <23215> item(S.[S. S → • R.3) aabS ⇒(j .[#.a].4.il].[c].1) aS ⇒ (i.0. Adding to chart: <10754> item(S.2)aabR[b]⇒ i i j ¯ j ¯ i 1 2 3 4 5 (i.3.[].ir].[d].a]. 3.b].2.0.ir].ir]. R → Rb | b ¯ j The following derivation is not possible (in particular step 4).[d. Adding to chart: <23085> item(B.il].[#.1.[].5) 22. R → a • . (#. Adding to chart: <27783> item(B.7) 27.8) yes The following example shows why some bookkeeping of the order of the derivation is required in Earley items.0.2. Consider the language Lww = {ww |w ∈ {a.0.[B. 0). In other words.0.[#.?) aaba i i ¯ i ¯ j 1 2 3 4 However.[].

S → aS • . S → aSc j 3. {i. d}. It cannot handle cases of what we call predict-complete ambiguity. {a. c. 2). completed-stack ambiguity and stack-position ambiguity. 4.5. S → aS • . R → bc ¯ i 6. R → bRc ¯ i 5. and at completer cases. 0). there is no way to control the correct derivation given no information on the pop moves has been stored. S. complete steps have to check that there is a corresponding pop-move item that has been completed for every item produced at a reduced push move. P ) where P is: 1. R → bRd ¯ j Grammar Gamb4 produces the following derivation: S ⇒ i#aSd ⇒ ji#aaScd ⇒ ji#aaRcd ⇒ i#aabRdcd ⇒ #aabbcdcd But it does not generate the string aabbcddc nor aabbdccd. #.2. This is depicted in the following ﬁgure 5. Example 19 Gamb4 = ({S. j}. 0. the complete operation of the previous algorithm does not specify the correct constraints. In other words. 2]. at some predict steps. R → [(#.2.2: Push and Pop moves on the same spine The following grammar produces alternative derivations which illustrate this issue.2. i 57 c) [(#. 4. 1. At this point. The exact prediction path that led to the current conﬁguration has to be transversed back in the complete steps. push push pop pop Figure 5. The predict-complete ambiguity In this case. GILS RECOGNITION USING EARLEY ALGORITHM b) [(#. 2] and b d. 1]. 2). S → R 7. S → aSd i 2. R → • ∗ • b c. 0). b. The ambiguity arises in the following conﬁguration S ⇒ aabR which would lead to the following items: [(#. 0] i 5.3 Reﬁning the Earley Algorithm for GIGs The Algorithm presented in the preceding section does not specify all the necessary constraints. R → bd ¯ j 4. R}. .

58

CHAPTER 5. RECOGNITION AND PARSING OF GILS ¯ A solution is to extend the graph-structured stack to include I nodes. Whenever a push item is

being completed it has to be matched against the complement node on the stack. The existence of ¯ a corresponding I node stored in the stack has to be checked whenever an item with a reduced push ¯ node is completed. The following ﬁgure 5.11 depicts a graph that includes I nodes (pop nodes). It also shows some additional edges (the dashed edges) that depict the corresponding active nodes in the I domain. We will discuss this issue again in the next subsection.

i,1 $,0 j,1

i,2

i,3

i,3

i,2

j,2

j,3

j,3

j,2

j,1

Figure 5.3: A graph structured stack with i and ¯ nodes i

Completed stack ambiguity The graph-structured stack we presented so far is built at prediction steps and no additional computation is performed on the graph at completion steps. Therefore there is no way to represent the diﬀerence between a conﬁguration like the one depicted in ﬁgure 5.2 and the one we present in ﬁgure 5.4.

A

push

B

pop

Figure 5.4: Push and Pop moves on diﬀerent spines Such a diﬀerence is relevant for a grammar like Gamb5 Example 20 Gamb5 = ({S, A, R, B}, {a, b, c, d, e}, {i, j}, S, #, P ) where P is: S→AB A→R A → aAb |ab

i

R → aRd |ad

j

B → cBd |cd

¯ i

B → cBe |ce

¯ j

5.2. GILS RECOGNITION USING EARLEY ALGORITHM

59

Grammar Gamb5 generates the string aadbccde but it does not generate the string aadbcced. If we consider the recognition of the string aaaddbccdde, it will generate the following stack nodes for the derivation A ⇒ aaaddb: a(i, j, 1)a(i, j, 2)a(i, j, 3)d(→ j, 3)d(→ j, 2)b(→ i, 1). The notation (i, j, 1) indicates that two nodes (i, 1) and (j, 1) where created at position a1 , and (→ j, 3) indicates that the node (j, 3) was completed at the position d4 . Consequently only the nodes (j, 3), (j, 2) and (i, 1) are completed at the derivation point S ⇒ aaaddbB. The edges depicted in ﬁgure 5.5 are all valid at position 3 (i.e accessible from the item [∆, 3, R → aaa • d, 3] in S 3 ). However they would be still valid at position 6: [∆, 3, B → α • d, 6] in S 6

i,1 $,0 j,1 j,2 j,3 i,2 i,3

∗ ∗

Figure 5.5: A predict time graph Therefore, it is necessary to distinguish between prediction and complete stages. We need to introduce a new edge, a completion edge. The arrows in ﬁgure 5.6 are intended to designate this completion edge. They also indicate that there is a diﬀerent kind of path between nodes. So, the simple lines indicate that there was a potential edge at the prediction step. Only those paths with additional arrows were conﬁrmed at a complete step.

i,1 $,0 j,1 j,2 j,3 i,2 i,3

Figure 5.6: A complete steps in the graph

Stack position Ambiguity Two (or more) diﬀerent stacks might have the same active nodes available at the same position. However those alternative stacks might correspond to alternative derivations. This issue is illustrated by the two stacks represented in ﬁgure 5.7.

60

CHAPTER 5. RECOGNITION AND PARSING OF GILS

i,1 $,0 j,1

i,2

i,3

i,1 $,0

i,2

i,3

j,2

j,3

j,1

j,2

j,3

Figure 5.7: Two alternative graph-structured stacks

The alternative graph-structured stacks depicted in ﬁgure 5.7 might be generated at diﬀerent positions, e.g. in the following alternative spines as illustrated in the following ﬁgure 5.8.

push pop

Figure 5.8: Ambiguity on diﬀerent spines Notice that although these stacks have the same active nodes, they do diﬀer in the nodes that can be reached from those active nodes. They even might be continued by the same pop complement part of the graph. It must be noticed that the active nodes from the graph structures in ﬁgure 5.8 are indistinguishable from each other. Some information must be added to make sure that they point to active nodes in diﬀerent graphs. The information that will enable to distinguish the corresponding nodes in the graph will be the position in which the push nodes are generated. This information replaces the order parameter that was used in the preliminary version of the algorithm. In this case the graph structured stack will be more like the one that is proposed in Tomita’s algorithm, in the sense that there is not an unambiguous length of the stack at each node.

i,5 $,0 $,0 j,1 j,2 j,3 j,4 j,5 j,8 i,6 i,7

i,1

i,2

i,3

Figure 5.9: Two alternative graph-structured stacks distinguished by position

2. Therefore. These edges will be represented then by triples: (newnode. for a node at position pi there might be pi−1 edges to other nodes. We say ∆i > ∆j if ∆i = (δ i . It is a pair (δ. GILS RECOGNITION USING EARLEY ALGORITHM 61 5. . On the other hand ∆− will designate a push node which has been removed by ∆− . It also creates an i-edge from initialnode to newnode.2. Push(newnode.4 Earley Algorithm for GIGs: ﬁnal version Revised Operations on the stack We will use the following notation. We will use a slightly more complicated version that takes into account completed nodes and the initial nodes introduced by the Push operation. Therefore the number of edges connecting a node to a preceding one is bound by the position of the current node. p) such that δ is an index and p > 0 (p s are integers). p) such ¯ ¯ that δ ∈ I. PushC(currentnode. ∆j = (δ j . It ﬁnds the preceding unreduced push node after one or more reductions have been performed. We will discuss it again below. pi ). as is speciﬁed in algorithm 5 and depicted in ﬁgure 5. p < 0. the path function obtains the nodes in I which can be active. initialnode). oldnode.5. We say ∆+ ∈ I. A node ∆+ designates a node corresponding to a push move on the stack.e.10.oldactivnode. These operations enable the computation of the Dyck language over the graph-structured stack. Therefore ∆+ will designate a node corresponding to a pop move which ¯ “removes” ∆+ . It retrieves all the nodes in I that are connected by an edge to the push node that currentnode reduces. and pi > pj . Creates a newnode if it is not in the graph and creates an edge from newnode to oldnode if necessary. A node can connect to any node at a preceding position. after a reduce operation has been done. i. pj ).initialnode). The following operations are possible on the graph-structured stack. Note that the position is determined by the corresponding position of the terminal introduced by the push production. precednode). It is a pair (δ. Path(currentnode). We will use also the complement notation to designate the ¯ corresponding complements. This operation is the equivalent of the previous Pop function with a stack ¯ that keeps record of the nodes in I. Creates a complete edge from currentnode to precednode if necessary. We say ∆− ∈ I. The modiﬁcations are ¯ necessary due to the fact that the graph-structured stack contains both nodes in I and I. A node ∆− designates a node corresponding to a pop move in the stack.

10: Paths and reductions in a graph structured stack with i and ¯ nodes i The following operation operates on the reverse direction of the Path function.1 j. ∆ − 3 ) add Path2(∆ − 3 ) to valueset return valueset S S i.2 i. Both Path and Path2 perform Dyck language reductions on the graph structured stack. Path obtains the closest non reduced nodes ¯ ¯ in I. −3 j. 2 j. Path2 performs them at complete time.62 Algorithm 3 . Path2 returns a set of nodes in I accessible from another node in I. −1 j. −1 j. .0 i. Path(∆ − 1 ): CHAPTER 5. ∆ + 2 ∈ I 1 2 3 4 5 6 valueset = {} ¯ For edge((∆ − 1.3 j. −2 j.1 j. While Path performs them at predict time. RECOGNITION AND PARSING OF GILS ¯ ¯ where ∆ − 1 .3 j. −3 i.0 j. named edgeC.−3 i. −2 j. Completed nodes are designated by a particular kind of edge.3 i. −2 i.1 $. and ∆ − 1 . ∆ + 2 ) add ∆ + 2 to valueset ¯ For edge(∆ − 1 . −2 S S S S S Figure 5.1 $.3 i.2 i. ∆ − 3 ∈ I. The portion of the graph that is already reduced corresponds to completed nodeswhich already matched their respective complements. The returned set of nodes represent points in the derivation at which to continue performing reductions at complete time. 2 j.−3 i.

p) such that δ ∈ I. . The vocabulary corresponding to the set of indices (I).e.1 j.3 j.3 j. p) such that δ ∈ I. -1 j. Two parameters represent the portion of the stack: the current active node ∆Ac and the initial node ∆In . ∆In .0 j. will be denoted by DI (i.11: A graph structured stack with i and ¯ nodes i New Earley items for GIGs Earley items have to be modiﬁed to represent the portion of the non reduced graph-stack corresponding to a recognized constituent. 2 j. The empty stack is then represented by the node (#. Path2(∆ − 1 ): ¯ ¯ ¯ where ∆ − 1 . p) such that δ ∈ DI and p is an integer. ∆2 ) add ∆2 to valueset ¯ For edgeC(∆ − 1 . We need also to represent those constituents that did not generate a node of their own ( a push or pop derivation). their ¯ ¯ complements (I) and the empty stack symbol (#).1 j. A → α • aβ. We use a substitution mapping cl from DI into DI ∪ {c}∗ . We say a node ∆+ is in I if it designates a pair (δ. A node ∆cl (or cl(∆)) is a pointer (cl(δ). ∆ − 3 ∈ I. -3 Figure 5. p < 0. p > 0. -2 j. -1 j. ∆ − 1 ∈ I) and : ∆2 ∈ I ∪ {#} 1 2 3 4 5 6 valueset = {} ¯ For edgeC((∆ − 1. p) (∆) in the stack. -3 S S paths $. deﬁned as follows: cl(δ) = cδ for any δ ∈ DI ∆cl represents a node (cl(δ). negative integers and zero respectively.5. and positive. We ¯ ¯ say a node ∆− is in I if it designates a pair (delta. GILS RECOGNITION USING EARLEY ALGORITHM Algorithm 4 . j] ∈ S i ¯ Nodes are represented by pairs of elements in I ∪ I ∪ {#}. p) to the node (δ. 0). ∆ − 3 ) add Path2(∆ − 3 ) to valueset return valueset c c S 63 $. DI = I ∪ I ∪ {#}). -2 j. 2 j.0 j. [∆Ac . but inherit the last generated node.2. We refer to these as transmitted nodes.

∆ + 2 . I the set of indices. ∆ − 3 ) and For Path(∆ − 3 . B I−edge α push or pop edge A Figure 5. ∆R 2) add Path(∆ − 1 . ∆R ) to Pathset . RECOGNITION AND PARSING OF GILS As we mentioned when we introduced the Push operation Push(newnode. ∆ + 2 ∈ I. ∆ + 2 ) such that ∆ + 2 ≥ ∆R add Path(∆ − 1 . we will make use of an additional type of edge. ∆R2 ) add Path(∆ − 1 .12: I-edges Now that we have introduced I − edges we present a second version of the path computation that takes into account I − edges (here ∆R ) as boundary points to deﬁne a path. This kind of edge relates ∆In nodes.12.oldactivnode. ∆ − 3 . ∆ + 2 . StorePath(∆ − 1 .64 CHAPTER 5. 1 2 3 4 5 6 7 8 9 10 11 12 ¯ If ∆ − 1 = ∆R : ¯ For edge(∆ − 1 . ∆R2 ∈ I ∪ I. ∆ − 3 ∈ I. The interpretation of these edge is that there is a path connecting the two ∆In nodes. ∆R . ∆R ): ¯ ¯ ¯ where ∆ − 1 . ∆R ) to Pathset ¯ For edgeC (∆−1 . ∆ + 2 . ∆R2 ) add Path(∆ − 1 ∆ − 3 . Algorithm 5 . ∆ + 2 . by the following Push function. ∆R2 ) to Pathset ¯ For edge(∆−1 . Notice that an I-edge can be identical to a push or pop edge. ∆ − 3 ) For Path (∆ − 3 . It also takes into account the diﬀerence between nodes corresponding to completed constituents (lines 7-12) and nodes corresponding to incomplete constituents (lines 1-6). ∆ + 2 . These edges will be introduced in the predict operation. and ∆ − 1 . I-edges are depicted in ﬁgure 5.initialnode). therefore we will call them I-edges. ∆ + 2 . ∆R2 ) to Pathset ¯ else if ∆ − 1 > ∆R ¯ For edgeC(∆ − 1 .

completer used in the For loop in 2 are modiﬁed as follows to perform the corresponding operations on the graph-structured stack: as we said. 0]} then accept 65 The structure of the main loop of Earley’s algorithm remains unchanged except for the requirement that the initial item at S 0 (line 1) and the accepting item at S n + 1 (line 4) have an empty stack Active and Initial node: (#. In the pop case there are two subcases (1. (#. This is also required for productions ¯ that check the top of the stack: (A → γ) when the triggering item Active node is in I. T.2. Prediction and Scanner Operations Prediction Operations will be divided in diﬀerent subcases..b) where the active node is in I. δ ∈ DI and the absolute value of p (abs(p)) refers to the position in w = a1 . S → S$ • . the function path is used. n ≥ 0. 0). In the second case.2. 0] 2 For 0 ≤ i ≤ n do: Process each item s ∈ S i in order performing one of the following: a) Predictor b) Completer c) Scanner 3 4 If S i+1 is empty. p0 ) designates an item initial node.5. scanner. to retrieve the active nodes in I. P ) be a GIG. I. The operations predictor.. 0). (#. p1 ) designates an item active node (∆Ac ) and I(δ 0 . S. [δ] . Reject. If i = n and Sn+1 = {[(#. 0).a): ¯ the active node in the triggering item is in I or (1. Let G = (N.an in which the index δ + in I was introduced. p) such that −n ≤ p ≤ n.2. pop or e-move). Ac(δ 1 . Create the Sets S i : 1 S0 = [(#. we represent nodes in the graph-structured stack with pairs (δ ± . Initialize the graph-structured stack with the node (#. and ai ∈ T for 1 ≤ i ≤ n. 0). 0). #. Let w = a1 a2 · · · an be an input string. S → • S$. 0). These subcases are constrained by the type of production applied (push. GILS RECOGNITION USING EARLEY ALGORITHM Algorithm 6 (Earley Recognition for GIGs) .

(A → γ) ∈ P δ2 and δ 2 ∈ I: add every [Ac(δ 2 . I(δ 2 . All the completer operations . A → • γ. p1 ). A → α • aβ. B → α • Aβ. i] to S i ¯ such that: (δ 3 . p3 ).2. (δ 0 . A → αa • β. Scanner If [∆Ac . p0 ). j] ∈ S i . p3 ) ∈ path((δ 1 . j] ∈ S i δ= and (A → γ) ∈ P such that δ ¯ or δ = [δ 1 ] or (δ 2 . B → α • Aβ. (δ 0 . (δ 0 . p1 ). p0 )) ¯ 1. ∆In . I(cl(δ 0 ). p1 ). I(δ 2 . p2 ). (δ r . pr )) 1. j] ∈ S i . RECOGNITION AND PARSING OF GILS If [Ac(δ 1 . I(δ 0 . (δ 3 . p2 ). (δ 1 . δ r . A → • γ. A → • γ. p2 ). (δ 0 . i] to S i 2. I(δ 0 . I(δ 2 . i] to S i and push( (δ 2 . p1 ). δ 1 ∈ I and δ 2 = δ add every [Ac(δ 1 . p1 ). p0 ).2. I(δ 0 .b Predictor Pop: Active Node is in I ¯ If [Ac(δ 1 . p2 ). p0 ) ) StorePath((δ 2 . p2 ). p0 ). B → α • Aβ. j] to S i + 1 Completer Operations The diﬀerent subcases of Completer operations are motivated by the contents of the Active Node ∆Ac and the Initial Node ∆In in the triggering completed item (item in S i ) and also by the contents of the Initial Node ∆I0 of the combination target item (item in S j ). p1 ). p2 ).66 1. pr )) and δ 2 = δ 3 and p3 = −p2 and push( (δ 2 . p1 ).3 Predictor e-move If [Ac(δ 1 . p2 ) ∈ path(δ 1 . p1 ). p2 ). j] ∈ S i and wi + 1 = a: add [∆A . i] to S i such that: p2 = i + 1. p1 ). p2 ). p0 ). ¯ such that: δ 2 = δ 1 and p2 = −p1 (A → γ) ∈ P δ2 and ¯ δ 2 ∈ I = δ¯ : 1 add every [Ac(δ 2 . ∆In . A → • γ. (δ 1 . p1 ).a Predictor Pop: Active Node is in I If [Ac(δ 1 .1 Predictor Push CHAPTER 5. I(δ 0 . p0 ) ) 1. δ 2 ∈ I: δ2 add every [Ac(δ 2 . p2 ). (δ 1 . p0 ) ) StorePath((δ 2 . j] ∈ S i and (A → γ) ∈ P and δ 1 . and push( (δ 2 . p0 ). B → α • Aβ. p2 ). p2 ).

b combines a completed triggering item generated by a push production (using the prediction operation 1. a}. p). As a result of the combination. p2 ).a Completer A. p3 ). therefore. A completion edge is introduced recording the fact that this push node ∆In has been completed. The active node ∆Ac is also in I or it is the empty stack (i. A → α • Bβ. p3 ). At this step. j] ∈ S i : for edge((δ 3 . I(δ 3 . 3 Use the standard terminology concerning Dyck languages as found for instance in [39]. If a subtree is in the Dyck language over a ¯ DI.1).3. The constraint that there is an I-edge between ∆In and ∆I0 is checked. p0 )) and for [Ac1(δ 0 .e ∆Ac = (δ 2 .3 e-move) and therefore its initial node is a transmitted node. ie. This is the reverse of predictor 1. ). and the active node has to contain its inverse. we need to check also whether the stack associated ¯ with each subtree is a proper substring of the Dyck language over I ∪ I. This is the equivalent of a production S → aS¯ for a Dyck language over the alphabet {a. the initial node ∆In is inherited by the result item. k] ∈ S j such that: ¯ δ 0 ∈ cl(I ∪ I) add [Ac(δ 2 . . However. For a subtree to be in the Dyck language over DI is as follows: the initial node has to contain the node for the ﬁrst index introduced in the derivation. p2 ). p0 ). k] to S i Subcase 3. (derived by Predictor 1. a reduction can be performed. p0 ) I(δ 0 . . I(δ 3 . GILS RECOGNITION USING EARLEY ALGORITHM 67 check properties of the combination target item in S j against edges that relate its the initial node ∆I0 to the initial node of the completed triggering item ∆In . No further constraints are checked. The idea is to be able to compute whether a tree has a valid stack (i. .2. ¯ 3. A → αB • β.5. The result item preserves the active node from the triggering item and the initial node from the combination target item. the transmitted nodes are consumed. Therefore if the information is stored in a three dimension table. p2 ) such that δ ∈ I ∪ {#} and 0 ≤ p2 ≤ n). (δ 0 . We use the symbol ‘ ’ hereafter to indicate that the information stored in the corresponding ﬁeld is not required in the computation. ∆I0 = (cl(δ). p3 ). ∆I0 ) (where the omitted element is the active node ∆Ac of the combination target). B → γ • . The ﬁrst completer subcase involves a combination item in S j that had been generated by an e-production. These edges are of the form (∆In . the initial node ∆In is in I.e. it means that only two dimensions are being used. ( . a stack that is in the ¯ Dyck3 language of the indices and its complements (I ∪ I)). Combination with an e-move item: δ 0 ∈ cl(I ∪ I) If [Ac(δ 2 .

It should be noted that the string position in which an index in I is introduced constrains the possible orderings of the control . j] ∈ S i δ 3 ∈ I. p0 ). I(δ 0 .c also combines a triggering item generated by a push production. p2 ).e ∆Ac = (δ 2 . ). p0 )) and for [ . In other words the active node ∆Ac is a closing parenthesis of the Dyck language that has not yet exceeded its opening parenthesis. The ﬁrst is −p2 < pI . I(δ 3 . B → γ • . add [Ac(δ 2 . (δ 0 . p2 ). ( . The existence of an edge between ∆In and ∆I0 is checked as in the previous cases.68 I_0: e−move CHAPTER 5. p3 ).13: Completer A 3. p0 ). δ 0 . In this case ¯ ¯ the active node ∆Ac is in I (i.14: Completer B Subcase 3.b Completer B: Push with Active Node in I ∪ {#}. RECOGNITION AND PARSING OF GILS I_3 I−edge edge I_3 Ac_2 + Ac_2 + − − Figure 5. δ 2 ∈ I ∪ {#}. (p2 > −1) If [Ac(δ 2 . p0 )) such that: ¯ δ 0 ∈ I ∪ I. A → αB • β. p3 ). I(δ 0 . k] ∈ S j pushC( (δ 3 . p2 ) such that δ 2 ∈ I and −n ≤ p2 < 0). p3 ). ∆In ∈ I. A → α • Bβ. There are two additional constraints. and (p2 > −1) : for edge((δ 3 . k] to S i and such that I_0 − + I_0 I−edge + − I_3 + push edge + Ac_2 + Ac_2 + Figure 5.

I(δ 3 .. i. ¯ 3.c). p2 ). ¯ (Ac ... p_3) (d_1.... A → αB • β.[(I0 .. and −p2 < p3 If [Ac(δ 2 . p3 ).c Completer C: Push with Active Node in I. p3 ). I(δ 0 . B → γ • . do not constitute a j valid stack conﬁguration for a subtree. k] ∈ S j such that: δ 0 ∈ I ∪ I. The substring of the Dyck language that corresponds to the completed subtree is indicated by the square brackets.e. p0 ). j] ∈ S i for edge((δ 3 .. so the node ¯ ∆In has to have been completed. A → α • Bβ. (p2 < 0).)Ac ] ¯ The second constraint requires that ∆In has to have a matching closing parenthesis. because ∆Ac should have met the corresponding matching Dyck element and a reduction should have been performed. 2) and ∆Ac = (¯ − 3). In other words: . δ 0 .. In this case the active node ∆Ac is also in I ( like in subcase 3.[(I0 .. ( . But there is a ¯ diﬀerent constraint: ∆Ac = ∆In . ( )) I_0 + − I_0 I−edge (d_1..5.15: Completer C Subcase 3. ∆Ac is the matching parenthesis of ∆In .. For instance.. add [Ac(δ 2 .. p0 )) and ¯ for [ . two nodes ∆In = (i.p_1) + − I_3 + push edge mirror push/pop (d_3. (p2 < 0) and ¯ −p2 < p3 there is a completed edge((δ 3 . p2 ). Following the preceding example )¯ has to be inside the square I brackets: (Ac . I(δ 0 . )In .−p_1) A_2 − A_2 − Figure 5. −p3 ).(I . ¯ ∆In ∈ I.d is the last case that combines a completed item generated by a push production..(In . GILS RECOGNITION USING EARLEY ALGORITHM 69 language elements. δ 2 ∈ I.)Ac ] ¯ ¯ The result item preserves the active node from the triggering item and the initial node from the combination item..2. k] to S i such that ¯ δ 3 ∈ I. p0 ). This constraint then expresses the fact that (Ac is outside the square brackets.. ).

(δ 1 .( p2 < 0). ¯ Subcase 3. p5 ) ∈ path2(δ 2 . This is the base conﬁguration to perform a Dyck reduction.e. (δ 1 . j] ∈ S i ¯ −p2 = p3 and δ 2 = δ 3 for edge((δ 3 . p3 ). p2 ) b) The reduction is performed by a single edge from the complement of the Active Node (∆Ac ) to a matching node of the initial node in the target combination item ∆I0 . (p2 < 0). and ∆Ac = ∆I If [Ac(δ 2 . B → γ • . + − i−edge Ac1: (d_1. p2 ) = (δ 3 . p1 ). The alternatives for performing a Dyck reduction on the graph are three: a) The reduction is performed by the path2 function: choose (δ 5 . The Active Node of the result item are updated. there ¯ ¯ is an edge ((δ 2 . A → α • Bβ. ∆I0 ) where ∆In = ∆Ac1 . becomes the updated Active node of . and checked to verify that they satisfy the control properties required by the case 3. the only diﬀerence is that ∆Ac was not completed yet at this stage (the path2 function requires completed nodes). p3 ). p5 . ). RECOGNITION AND PARSING OF GILS ¯ (δ 2 . I(δ 0 .16: Completer D The following Completer cases involve completed triggering items generated by pop productions. product of the reduction. (δ 0 . ∆Ac1 . I(δ 3 . p0 ). p0 )) and ¯ for [Ac(δ 1 .d. k] ∈ S j such that: δ 0 ∈ I ∪ I. c) The completed item initial node and active node are equal (∆In = ∆Ac ). Therefore the whole stack of the completed triggering item can be reduced and the active node of the result is updated to a node that precedes ∆In in the stack. This option is similar to the previous one. p1 ). A node preceding the active node (∆Ac1 ) of the target item (δ 1 . k] to S i I_0 such that ¯ δ 3 ∈ I.p_1) I_0 + − reduced path Ac_2 = I_3 Ac_2 − Figure 5. )). (δ 0 .p_1) I_3 + push edge Ac1: (d_1.e corresponds to edges (∆In . −p3 ) such that δ I ∈ I and 0 < p3 ≤ n. p1 ). ¯ ¯ 3.70 CHAPTER 5. p2 ). p0 ).d Completer D: Push with Active Node in I. −p2 ). add [Ac(δ 1 . In other words. A → αB • β. −p0 . I(δ 0 . δ 2 ∈ I. which is ∆Ac1 . p1 ). i. p1 )(δ 5 .

and (δ 5 . Pop items with Push items: p0 > 0. in other words ∆Ac > ∆In . p1 ). p2 < 0 : Compute path2 (δ 2 . j] ∈ S i such that δ 2 δ 3 ∈ I. I(δ 0 . ) add [Ac(δ 5 . p5 ) = (δ 0 . δ 0 ∈ I and p0 > 0.c. p5 ). −p0 ) 2 else if p2 = p3 . (δ 1 . ∆In ). for [Ac(δ 1 . p5 ) ≥ (δ 0 . k] ∈ S j such that ¯ If p1 > p0 . p0 )) where ¯ δ 3 = δ 1 . p3 = −p1 . p5 ). p3 ). 5δ ¯2 6 An was introduced after δ 0 was reduced. and −p2 > p0 and (δ 5 .17: Completer E. p2 ). 3. p0 ). A → αB • β. These two alternatives are allowed by p2 > p3 . −p0 )4 ¯ ¯ else if −p2 > p0 and there is an edge (δ¯ . (∆Ac− ). ). A → α • Bβ.5. −p0 . δ 0 ∈ I and p2 > p3 4 There ¯ is a complete path of I elements that reaches the one that complements δ 0 . . I(δ 0 . the Active Node is positive (∆Ac+ ). p1 ). p2 ) for edge((δ 3 . (δ 0 . p2 ). last case Subcase 3. p1 )(δ 5 .6 3. GILS RECOGNITION USING EARLEY ALGORITHM the result. which has not yet exceeded the position of its opening parenthesis.δ 2 = δ 3 for edge(δ 1 .e Completer E. p3 ). p5 ) ∈ path2(δ 2 . The information that ∆In was completed is stored by the completed edge (∆In . and (δ 5 . k] to S i I_0 5 71 + − i−edge Ac_1 I_0 (d_4.p_4) path + − + pop edge reduced graph Ac: (d_4. The Active node ∆Ac is updated according to the performed reduction. δ 1 ∈ I.f considers the combination of a pop item with a push item and checks the properties of the Active Node (∆Ac ) to verify that it satisﬁes the control properties required in 3.p_4) + − I_3=A_2 Ac_2 − Figure 5. (δ 0 . p0 ). Either the Active Node is a closing parenthesis. This case is relevant for the language Lgenabc edge to itself. Part of this constraint might be speciﬁed in the Completer Case G. alternatively.2.f Completer F. I(δ 3 . −p2 ). B → γ • . or exceeds it. Pop items with Push items and graph reduction ¯ If [Ac(δ 2 . p3 .

( . p2 ). p3 ).g combines completed items generated by pop productions with target items also generated by pop productions. j] ∈ S i : such that p2 > p3 for edge((δ 2 . 7 Here we could state the constraint p2 > p0 . (δ 3 . p0 ). I(cl(δ 3 ). p2 ). j] ∈ S i : for [Ac(δ 2 . RECOGNITION AND PARSING OF GILS If [Ac(δ 2 . p3 ). p3 )( ) I_0 + I_0 i−edge + I_3 − pop edge Ac_2 > I_3 Ac_2 + Ac_2 + − − Figure 5. p2 ). A → αB • β. p3 ). p0 ). p3 )( ) 3. k] to S i The following table summarizes the diﬀerent Completer cases. I(δ 0 . j] ∈ S i such that δ 3 ∈ I. B → γ • . k] ∈ S j : add [Ac(δ 2 . p2 ). ( .72 CHAPTER 5. I(δ 3 . k] to S i and pushC edge (δ 3 . Therefore the target item has to have the same contents in the Initial and Active node as the completed item. (δ 0 . p3 ). (δ 0 . p2 ). p0 )) for [ . A → α • Bβ. δ 0 ∈ I for [ . p0 ). ). p3 ). p0 )). k] ∈ S j add [Ac(δ 2 . p2 ). Subcase 3. I(δ 0 . p2 ). p0 ). Completer H e-move If [Ac(δ 2 .18: Completer F The following subcases complete the remaining alternatives. Subcase 3. . I(δ 0 . ¯ for edge((δ 3 . I(δ 0 .g Completer G Pop items combine with Pop items7 ¯ If [Ac(δ 2 . p2 ). (δ 3 . k] ∈ S j add [Ac(δ 2 .h combine completed items generated by the 1. B → γ • . or compute a graph reduction if the condition is not met. A → αB • β. k] to S i pushC edge (δ 3 . A → α • Bβ. B → γ • . p3 ). A → αB • β.3 predictor. A → α • Bβ. 3. ). I(δ 3 .

therefore the pop procedure might take time O(i2 ) for each set S i . It has a maximum of n iterations where n is the length of the input. Predictor e-move and Predictor Push operations on an item each require constant time. −) pushC(∆In . p2 .19: Completer G Summary of Completer Cases CASE A B C D E F G H COMPLETED ITEM +/+ + + transmitted ACTIVE NODE +/+ ¯ . Each item in S i has the form: [Ac(δ 1 . −) 5. p1 ).(∆A > ∆In ) +/ +/TARGET ITEM transmitted +/+/+/+/. ≤ i Thus there might be at most O(i3 ) items in each set S i . I(δ 2 ..∆Ac + + +/-. might require O(i2 ). COMPLEXITY ANALYSIS I_0 73 − I_0 i−edge − I_3 Ac_2 − Ac_2 − Figure 5. Scanner.5. For each active node there might be at most i edges. A → α • Bβ. p1 . . Predictor pop.3. which may have O(i) active nodes. transmitted Speciﬁc Actions ∆I 0 ← ∆In pushC(∆In .3 5.(∆A = ∆I ) +/. ∆I0 ) ¯ check for ∆In reduce: ∆A ← ∆In − 1 reduce with path2 pushC(∆In .3. p2 ). j] where: 0 ≤ j.1 Complexity Analysis Overview The algorithm presented above has one sequential iteration (a for loop).

{a. p0 . {i.B → b 9. B. k.B → b ¯ i 5. also in S j .. This is a general analysis. k] ∈ S j (i = j).e. }. p0 ). }. C → cC ¯ i 6. E}.h ) can combine an item from S i : [Ac(δ 2 . deterministic.B → bB n k m n 8. B → α • γ. I(δ 3 . In such cases the number of items in each set Si is proportional to i. p2 ). I0(δ 0 . C. while the indexing is so to speak. P ) where P is : 1. m ≥ 1} ∪ {a b c d |n. m + k ≥ n} . only two dimensions are taken into account from the three dimensional table where i-edges and edges are stored. i. only one indexing alternative can apply at each step in the derivation. This is true even for some ambiguous grammars such as the following: Gamb = ({S. j] where: 0 ≤ j. O(i) and the complexity of the algorithm is O(n3 ). #. (δ 0 . #. A → α • Bβ.C → cC 10. B. ≤ j such that there is an i−edge((δ 3 . Once the CF backbone chooses either the “BC” path or the “DE” path of the derivation.a to 3. A → α • Bβ. pj ]. I(δ 2 . The Completer Operations (3. p0 )).74 CHAPTER 5. then the complexity of this operation for each state set is O(i5 ). c. P ) where P is S → aSd i S → BC S → DE n m n n B → bB ¯ i B→b ¯ i C → cC E → cE ¯ i C→c E→c ¯ i D → bD D→b n n m n L(Gamb ) = {a b c d |n. S. the ambiguity resides in the CFG backbone. There are S n iterations then the time bound on the entire 1-4 steps of the algorithm is O(n6 ). p3 . In other words. ≤ i with at most all [ . C → c L(Gam2 ) = {a b c d |n. p3 ). b. b.e. k ≥ 1. C}.B → bB ¯ i 4. p2 . provided the information in the node Ac1(δ 1 . c. where 0 ≤ j ≤ i Languages that have this property will be called constant indexing languages. The required time for each iteration (S i ) is thus O(i5 ). where: 0 ≤ j. Given that there are at most O(i3 ) items in each set. if for each item there is only one value for p1 and p2 for each i. This is in general the case except for some restricted cases in which the node ∆Ac1 is bound to the node ∆In and therefore does not increase the combinatorial possibilities. p3 ).S → BC 3. d}. m ≥ 1} In this case. It can be observed that this algorithm keeps a CFG (O(n3 )) complexity if the values of p1 and p2 are dependent on i. d}. {a. We consider in detail each subcase of the Completer in the next subsection.C → c ¯ i 7. There are at most O(j 2 ) such possible combinations. m.. RECOGNITION AND PARSING OF GILS The computation of the Path function might require O(n3 ) also. [Ac(δ. i. p1 ). p1 ) is not taken into account in the combination.S → aSd i 2. A diﬀerent case of ambiguity is Gamb2 = ({S. p2 ). {i. D. S.

C}. so the following results hold: O(n6 ) is the worst case. k ≥ 0.3. b. 7 and 8 would be bounded by the square of the number of b’s scanned so far.3. O(n2 ) for unambiguous context free back-bone grammars with unambiguous indexing and O(n) for bounded-state8 context free back-bone grammars with unambiguous indexing. S. P ) would produce items proportional to i in each set S i : S → aSd i S → BC B → bB ¯ i B→ C → cC ¯ i C→ L(Gam3 ) = {an bk cm dn |n ≥ 1. Unambiguous indexing should be understood as those grammars that produce for each string in the language a unique indexing derivation. c. B. Complexity results concerning formalisms related to Natural Language (including CFLs) mostly are worst case results (upper bounds) and they do establish polynomial parsing of these grammars. However. There is an important multiplicative factor on the complexity computed in terms of the input size which depends on the size of the grammar (see [6]). we keep separate the size of the context-free backbone and the indexing mechanism. The properties of Earley’s algorithm for CFGs remain unchanged. push. most algorithms for CFGs. This will allow to compare what is the impact of the indexing mechanism as an independent multiplicative factor. There are no mathematical average case results. COMPLEXITY ANALYSIS 75 In this case (where the ambiguity is between a pop and an epsilon-move the number of items corresponding to the rules 3. the similar grammar Gamb3 = ({S. All average case results reported are empirical. and other grammar formalisms run much better than the worst case. m + k = n} Therefore. the real limiting factor in practice is the size of the grammar. {a. 4. The size of the grammar designated by |G| corresponds to the number of rules and the number of non-terminals. In the analysis we present here. m.5. Usually. O(n3 ) holds for grammars with constant or unambiguous indexing. }.2 Time and Space Complexity In this subsection we compute the time and space complexities in terms of the length of the input sentence (n) and the size of the grammar. or pop) through the same derivation CF path and b) a diﬀerent index value used in the same type of stack operation. d}. the sources of increase in the time complexity are a) ambiguity between mode of operation in the stack ( . #. 8 Context Free grammars where the set of items in each state set is bounded by a constant. . {i. In practice. 5. TAGs. The expensive one is the ﬁrst case.

∆In . There might be O(I · ∆In − 1) possible values for each edge and ∆In . The same grammar rules may apply at most n2 times (if it is a pop rule): there might be O(I ·n) possible values for Ac(δ 1 . ∆In . p2 ). p1 ). B → γ • . Completer Case 1. j] ∈ S i and (A → γ) ∈ P : δ add every [(δ 2 . Complete The scanner operation requires constant time. ∆I0 . k] ∈ S j add [∆Ac . and for each value there might be O(I · n) path values. B → α • Aβ. Predictor Operations If [Ac(δ 1 . The push (1.2) and predictor 1. ∆In . It checks the current word (input aj ) against the terminal a expected by the scanner. A → α • Bβ. The same grammar rule may have diﬀerent values for δ. ∆I0 ) and item: for [ . the complexity of the predictor operation is: O(|I|2 · |G| · n4 ). ∆3 . We consider now the more simple cases of the Completer operation which have the following shape. A → • γ. p1 ). Predict. There is still the need to check for duplicates of the grammar rules. j] ∈ S i : for every i-edge (∆In . j] ∈ S i and wi + 1 = a: add [∆A . It depends on k and p0 : O(|I| · |G| · n2 ). no recalculation of ∆Ac (No reduction involved) If [∆Ac . A → αB • β. RECOGNITION AND PARSING OF GILS Analysis of Scan. there are at most O(|I| · n) edges in a path and we consider edges to two vertices: the active node and the initial node. ∆I0 . Scanner If [∆A . C. A → α • aβ. j] to S i + 1 Predictor operations have in general the following shape. i] to S i A grammar rule is added to the state set. . The computation of the path in Predictor takes at most O(n3 ) for each vertex. k are bounded by n.76 CHAPTER 5.3 operations take constant time regarding the input size. A → αa • β. ∆0 . Given there are two stack possible values (∆Ac and ∆In ). k] to S i The complexity is bound by the number of elements in S j that satisfy the edge condition.

A → αB • β. We will analyze each of them in turn.∆In and j : 0 ≤ j. performing reductions.d Completer D: Push with Active Node in I If [∆Ac . ¯ ∆In = ∆Ac1 . ∆IO ∈ I such that ¯ ∆Ac = ∆I . ∆I0 ) where for [∆Ac1 . j] ∈ S i for edge(∆In . so its bound is O(|I| · i3 ) for each set S i (∆Ac ) is bound by i). ∆Ac1 . add [∆Ac1 . and −pAc > pI0 and ∆I0 ∈ path2(∆Ac ) ¯ ¯ else if −pAc > pI0 and there is an edge (∆Ac . A → α • Bβ. A → α • Bβ. Pop items with Push items that re-compute the value Active node. ∆In . A → αB • β. ∆Ac1 . COMPLEXITY ANALYSIS 77 In each set in S i there might be at most O(|I|2 · |G| · n3 ) items. So the total is n × O(|I| · n) × O(|I| · |G| · n2 ) × O(|I| · |G| · n2 ) = O(|I|3 · |G|2 · n6 ) 3. ∆I0 . n. ∆IO and k produce give O(n3 )). pIn < 0 : Compute path2(∆Ac ) for edge(∆In . ¯ There are at most O(|I| · |G| · n2 ) items in S j that satisfy this condition. ∆In . Each such item can be combined with at most O(|I|2 · |G| · n3 ) items in each set in S j . ∆I0 . B → γ • . recalculation of ∆Ac : Completer D and Completer E ¯ 3. These additional operations are performed provided certain constraints are met. There are O(n) possible values for each ∆Ac . This requires the pA value of ∆Ac to be equal to −pI in ∆In (their integer values are opposites). k] to S i ¯ In each set in S i there might be at most O(|I|·|G|·n2 ) items that satisfy the condition ∆Ac = ∆I . j] ∈ S i such that ∆Ac ∆In ∈ I. ∆Ac1 . ) is done in constant time.3. Subcase 1 ¯ If [∆Ac . Total complexity is then n × O(|I|2 · |G| · n3 ) × O(I · G · n2 ) = O(|I|3 · |G|2 · n6 ) The remaining cases of the Completer involve more complex operations because the value of ∆Ac has to be recalculated. k] ∈ S j such that: ∆0 ∈ I ∪ I. B → γ • . ∆I0 . ∆I0 . given the node ∆Ac1 has to be considered to compute the result item added to the S i set ( the values of ∆Ac .5. ∆I0 . ) ¯ add [∆I0 .e Completer E. Checking if ∆I0 ∈ ¯ ¯ path2(∆Ac ) or there is an edge (∆Ac . pAc . Completer Case 2. ∆0 ) and ¯ for [∆Ac1 . ∆I0 . k] ∈ S j such that the following conditions imposed on the edges are satisﬁed: ¯ if pAc1 > pI0 . abs(pAc ). abs(pIn ). k] to S i Computing the set path2 for each ∆Ac takes O(|I| · n2 ) time.

q. k. |D. rs] However the work load can be set either in the indexing mechanisms as is shown in the equivalent completor from [74]. within the same time bounds adding an operation to update the active node reducing all possible paths. Therefore if the set of indices is relatively small there is not a signiﬁcant change in the inﬂuence of the grammar size. ∆5 . Subcase 2 ¯ If [∆Ac . B → γ • .γ]Γ2 . the impact of the grammar size might be higher for the LIG algorithms and the impact of the indexing mechanism smaller. j. |D. ) add [∆5 . If we compare the algorithm with LIG algorithms.] → Γ1 B[. We have seen then that O(|I|3 · |G|2 · n6 ) is the asymptotic bound for this algorithm.e Completer E. the only change corresponds to the added size of I. |C. RECOGNITION AND PARSING OF GILS Total complexity is then n × O(|I|2 · |G| · n3 ) × O(|I| · |G| · n2 ) = O(|I|3 · |G|2 · n6 ) 3. Total complexity is then n × O(|I| · n) × O(|I| · |G| · n2 ) × O(|I| · |G| · n2 ) = O(|I|3 · |G|2 · n6 ) ¯ Finally we have not considered the case of the path2 with diﬀerent values than ∆I0 . k. η.b..γ]Γ2 ... ∆In . r. that involves the combination of three constituents: [A[. −] [B → Γ3 • . s] [A[.] → Γ1 • B[. ∆I0 ) where ¯ ∆In = ∆Ac1 and items for [∆Ac1 . These can be done as a separate ﬁltering on the completed items in S i . η. j] ∈ S i such that ∆Ac = ∆In ∈ I: for edge(∆In . q] [C → Γ4 • .γ]Γ2 . j. p. |−. i. used to parse TAGs. Pop items with Push items that re-compute the value Active node. where the set of nonterminals is {t.] → Γ1 • B[. γ. The higher impact of the grammar size would be motivated in the following kind of completer required by LIGs (from [4]). ∆I0 ..}. A → α • Bβ. i. −. k] to S i There are at most O(|I| · |G| · n2 ) items in each set S i that satisfy the condition ∆Ac = ∆In ¯ There are at most O(|I| · |G| · n2 ) items in each set S j that satisfy the condition ∆In = ∆Ac1 There are at most O(|I| · n) edges for each ∆Ac1 .78 CHAPTER 5.. ∆In .. p. −. k] ∈ S j for edge(∆Ac1 . A[. If we compare the inﬂuence of the grammar size on the time complexity of the algorithm for GIGs and the one for CFGs. ∆Ac1 . A → αB • β.

PROOF OF THE CORRECTNESS OF THE ALGORITHM Type 4 Completor: 79 t[η] → • t[η r ].. i.5. α ⇒ ai+1 . p. i] is inserted in the set S j if and only if the following holds: 1. its space complexity is O(n4 ). S ⇒ a1 . k. i.ηη r ] 5.. Given there are four parameter bound by n in each item. j. j.. i.. therefore it can be done in a n × n × n table.η] → t[. Storing the combination of i-edges and edges involves three nodes.20: Earley CFG invariant . q. l b[η] → ∆ • . t[. aj Figure 5..ai Aγ 2.aj ∗ ∗ S γ A η α β a1 . Storage of the graph-structured stack takes O(n3 )... and the number of possible nodes is bound by n. q. i t[η r ] → Θ • . ai a i+1 .4 Proof of the Correctness of the Algorithm The correctness of Earley’s algorithm for CFGs follows from the following two invariants (top down prediction and bottom-up recognition) respectively: Proposition 5 An item [A → α • β. −. p. k t[η] → t[η r ] • ... −.. l A note on Space Complexity The space complexity is determined by the storage of Earley items.4.

Let β and γ be in (N ∪ T )∗ .X n is a production of type (c. 173-185 and [87] for a control language representation for LIGs. If A → aX 1 .X n is a production of type (c.80 CHAPTER 5. deﬁne the language of a GIG G to be the control language L(G.. # ⇒ a1 . P ) as follows. #. taking into account the operations on the stack.. w be in T ∗ and X i in (N ∪ T ). We can obtain an explicit control language9 modifying the deﬁnition of derivation for any GIG G = (N.. µ = µ [x] or µ = [x].. #δxδ y ⇒ wX 1 .. This is speciﬁed in terms of the Dyck language over ¯ I ∪I 5. x ∈ I.. # ⇒ w.. then: µ wAγ. .) (i.X n γ. If A → X 1 . #δx ⇒ βX 1 .ai Aγ. #δ ⇒ waX k . #δx ⇒ wX 1 . we address the correctness of the algorithm as follows: Proposition 6 (Invariants) . T. p0 ).. If A → X 1 . y ∈ I.. S.... #ν for some γ ∈ V ∗ and some ν ∈ (I ∪ I)∗ . C): {w| S. ∗ An item [Ac(y.. #δxδ y¯ x Then. then: ¯ µ wAγ..X k is a production of type (a..) or push: µ = x. Assuming such an alternative deﬁnition of a GIG language. #δx¯ x ¯ 4... I(z.) or pop : µ = x. #δx 2. x ∈ I.. S. #δ and w is in T ∗ . x ∈ I) then: βAγ. x in I. #δx 3.. δ is in C }. #δ ⇒ βX 1 . A → α • β. 1.X k γ.e. Deﬁne C ¯ to be the Dyck language over the alphabet I ∪ I (the set of stack indices and their complements). I. If A → X 1 . δ be in I ∗ . #δ or βAγ. L(G) to be: {w|#S ⇒ #w and w is in T ∗ }.1 Control Languages ∗ We deﬁned the language of a GIG G. RECOGNITION AND PARSING OF GILS The corresponding invariants of Earley’s algorithm for GIGs can be stated in a similar way... i] is a valid item in the Set S j if and only if the following holds: ¯ 1.X n is a production of type (b.X n γ. x ∈ I.. 9 See ∗ [25] for control languages pp..X n γ.4... and δ y ∈ C then: ¯ µ wAγ. It is apparent that both deﬁnitions of a GIG language are equivalent.X k γ.. p1 ).) or pop : µ = x.

ν. ∗ S ν a 1 . z. speciﬁes the properties for the diﬀerent types of productions that generated the current item. 5. It will also help to understand the implementation of the algorithm we detail in the appendix. δ ∈ DI iﬀ z µy π = epsilon.21: GIG invariant We will use Parsing Schemata to prove this proposition.aj .21 depicts the properties of the invariant. speciﬁes the constraints related to the position correlation with the strings in the generated language. Condition c. µπ ∈ (I ∪ I)∗ . This framework enables the analysis of relations between diﬀerent parsing .4. ∈ cl(δ ). #νδ ⇒ ai+1 . d.2 Parsing Schemata We use Parsing Schemata. # γ . #νz µy π Such that: a.. a framework that allows high-level speciﬁcation and analysis of parsing algorithms [75. z. else δ = ¯ ¯ ¯ c. The remaining conditions specify the properties of the string νz µy π relative to the control language C. Figure 5. PROOF OF THE CORRECTNESS OF THE ALGORITHM 2. π ∈ C and νz µy πρ ∈ C for some ρ ∈ (I ∪ I)∗ . which naturally embed the invariant properties of the Earley algorithm for CFGs..5. Condition b. α.α η β µ .. ¯ b. speciﬁes that the item has a transmitted node from the graph if the empty string was generated in the control language... i+1 aj ν z µ yπ Figure 5. y = y . 76]. p0 ≤ i + 1 and p1 ≤ j.4. y ∈ I ∪ I iﬀ z = z . y π A z ai a . δ = z iﬀ δ ∈ I ∪ I.. (A → αβ) ∈ P δ 81 3. Condition d. speciﬁes the properties of information of the graph-structured stack encoded in the item. Condition a.

. A set of ﬁnal items.an that conforms to the item in question. [A → αB • β.[72]). 0. i. j]}. i. A ﬁnal item F(PEarley ) ∈ I is correct if there is a parse tree for any string a1 .. 0]}. n] |S ⇒ a1 . RECOGNITION AND PARSING OF GILS algorithms by means of the relations between their respective parsing schemata. j]|S ⇒ a1 .. Parsing schemata are closely related to the deductive parsing approach (e... Parsing Schemata are generalizations (or uninstantiations) of a parsing system P. n]}. DPred .aj } ∗ . j. . as we already saw are stored in sets according to each. As an example we introduce the Earley Schema for CFGs.g.. Earley operations are deﬁned by the allowed deductions: DScan . deﬁned by I Earley below. 0. A Parsing schema extends parsing systems for arbitrary grammars and strings.. We present parsing schemata rather informally here. DScan = {[A → α • aβ. then the consequent ξ is generated by the parser.an ∈ Σ∗ by: I Earley = {[A → α • β... [B → γ • δ. j] [A → αa • β. A parsing system P for a grammar G and a string a1 . Deduction steps are of the form η 1 . DComp . j]} DInit = { [S → • S.. DComp = {[A → α • Bβ. j.. The corresponding set of items in the Schema is encoded by an additional parameter in the items Schema items.ai Aγ ∧ ∗ ∗ α ⇒ ai+1 . F ∈ I. i. represent the recognition of a [B → • γ. V(PEarley ) = {[A → α • β. say j. i] | a = ai ∧ 1 ≤ i ≤ n}. i... j]}. i.an } The set of valid items is deﬁned by the invariant of the algorithm. j] DEarley = DInit ∪ DScan ∪ DPred ∪ DComp F Earley = {[S → S • .. j. [a. η k sentence. ξ which means that if all the required antecedents η i are present. k]. i − 1. position in the string. i. j]. Parsing Schema 1 (Earley Schema for CFGs) . C Earley = {[S → S • .82 CHAPTER 5.an is composed of three parameters a) I as set of items that represent partial speciﬁcations of parse results b) H a ﬁnite set of items (hypothesis) encodes the sentence to be parsed and D a set of deduction steps that allow to derive new items from already known items. This parsing schema is deﬁned by a parsing system PEarley for any CFG G and any a1 . k.. Earley items. j + 1]} such that A → αβ ∈ P and 0 ≤ i ≤ j HEarley = {[a. 0. j + 1] DPred = {[A → α • Bβ. The input string is encoded by the set of hypothesis HEarley .

5. The parsing schema for GIGs corresponds to the algorithm 6 presented in section 5. It can be observed that the major diﬀerences compared to the CFGs schema are the addition of diﬀerent types of Prediction and Completer deduction steps. η kj Those deduction steps that compute the the Control language are DPath a . Items in IC EGIG will participate in some restricted deduction steps. and DPrPop2 have the following shape. and they introduce prediction items η p in IC EarleyGIG . DPath2 a . η kj η ij ∧ η p This kind of deduction step can be understood as shortform for two deduction steps. Prediction Push and Pop deduction Steps. DPrPop1 . a diﬀerent set of items. However there is an additional type of deduction step performed in this parsing schema. will be used to perform the corresponding deduction steps. η ik .3 Parsing Schemata for GIGs The parsing schema for GIGs presented here is an extension of the parsing schema for CFGs given in the previous subsection. A parsing system (P) is complete if F(P) ∩ V(P) ⊇ C(P) (all correct ﬁnal items are valid). DCompF . A Parsing system is correct if F(P) ∩ V(P) = C(P) 5. will represent edges and paths in the graph.4. DPrPush .2.4. and this corresponds to the control language. Therefore IC EGIG . DPath2 b . and they introduce completion items η p in IC EarleyGIG . Those items in IC EGIG . DPath b . and DCompG have the following shape. η ij η jj ∧ η p Completers DCompB . PROOF OF THE CORRECTNESS OF THE ALGORITHM 83 Deﬁnition 12 A parsing system (P) is sound if F(P) ∩ V(P) ⊆ C(P) (all valid ﬁnal items are correct). Predictor steps can be decomposed as: η ij η ij η jj ηp η ij ηp Completer Steps can be decomposed as: η ik . η kj η ik .

j]. 0]}.. #. p1 ). ∆In . ∆I0 ] | δ ∈ I]}. 0). A → α • Bβ. ∆Ac . B → • γ. i. B → • γ. j + 1). popC. (δ 1 . A → α • Bβ. 0). p1 )+. ∆I0 )]} ∪ {[P. j] |ν = or ν = [δ Ac ]} ν DPrPush = {[∆Ac1 . j. (δ 2 . j] ¯ ¯ [(δ 1 . j. B → • γ. (δ 1 . P ) and any a1 . i − 1. A → α • Bβ. j + 1] [∆Ac . ∆In .an ∈ Σ∗ by: I EGIG = {[∆Ac . ∆In ∈ {(δ. ∆I0 . i. path. A → αa • β. ∆I0 . RECOGNITION AND PARSING OF GILS Parsing Schema 2 (Earley Schema for GIGs) . [a. j] [(δ 2 . j + 1). I.. ∆2 ]} such that ∆i ∈ {(δ. j] ∧ δ2 [push. (δ 2 . S → • S$. or δ = cl(δ )} . ∆1 . ∆In . S. 0. DScan = {[∆Ac . A → αβ ∈ P 0 ≤ i. j] [∆Ac . j + 1]} DPrE = {[∆Ac . −p1 ). ∆I0 ] | δ 2 ∈ I}. push. j + 1). A → α • β. DInit = { [(#. ∆I0 . p)|δ ∈ DI. −p1 ). −p1 ). j]} such that ∆Ac . A → α • aβ. cl(∆)I0 . DPrPop1 = {[(δ 1 . ¯ δ1 . ∆Ac1 .84 CHAPTER 5. (δ 1 . i. i. i] | a = ai ∧ 1 ≤ i ≤ n}. This parsing schema is deﬁned by a parsing system PEGIG for any GIG G = (N. j. j. i. (#. p)|δ ∈ DI ∧ 0 ≤ p ≤ j} and P is in {pop. path2} HEGIG = {[a. i. ∆Ac1 . pushC. j] ∧ ¯ ¯ [pop. T. p ≤ j and IC EGIG = {[P.

PROOF OF THE CORRECTNESS OF THE ALGORITHM ¯ DPath a = {[pop. ∆R ]. ∆3 +. ¯ δ1 85 ¯ DPath c = {[pop. ∆1 . j]. [path. B → • γ. k] [∆Ac +. . ∆1 +. ∆R3 = ∆R4 . ∆I0 . ∆2 +. ∆1 +. j] ∧ [pushC. P = push) ∨ (∆R1 < ∆1 +. [∆In +. ∆R ]. ∆R1 ] ¯ [path. k. B → γ • k. P = pushC)} DCompA = {[∆Ac . B → γ • . ∆R1 ]. ∆R2 = ∆R1 . . ∆3 +. P = push) ∨ (∆R < ∆1 +. P = pushC)} ¯ DPath b = {[pop. i. [∆In . i. ∆1 − . [P. ∆R3 = ∆R1 . ∆R2 ] ¯ [path. ∆I0 . [path. ∆R3 ] | (∆R1 = ∆1 +. ∆R3 = ∆R1 . j]. ∆]. ∆4 +. DCompB = {[∆Ac +. ∆1 . ∆I0 ] [∆Ac1 . ∆1 +. i. j]. P = pushC)} ¯ DPath d = {[pop. ∆R3 = ∆R2 . ∆2 −. ∆1 −. ∆R1 ] | − same conditions P atha } DPrPop2 = {[∆Ac −. ∆I0 ]} DCompC = {[∆Ac −. ∆Ac −. ∆In . ∆3 −. ∆2 +. ∆Ac −. ∆1 −. ∆In . k] [∆Ac . ∆3 −.5. ∆3 −. ∆1 − . [path.4. ∆I . ∆I0 . i. A → α • Bβ. ∆1 +. ∆I ] . [path. j] ∧ [pop. ∆R1 ]. ∆2 −. ∆2 +. k]. ∆1 +. [P. [path. ∆1 −. ∆I0 ] [∆Ac1 . ¯ [P. j. ∆R3 ] | (∆R1 = ∆1 +. ∆1 −. ∆I ]|δ 1 ∈ I}. ∆I . ∆R1 ] ¯ ¯ ¯ ¯ [∆1 . [∆In +. A → αB • β. ∆1 +. B → γ • . ∆3 +. ∆3 − . P = push) ∨ (∆R1 < ∆1 +. ∆I0 ] ¯ ¯ [∆Ac1 . ∆R2 = ∆R . ∆In +. ∆1 +. A → α • Bβ. [pushC. [P. A → αB • β. CL(∆)I0 . j]. ∆1 +. ∆1 −. ∆2 −. k. ∆In +. ∆1 − . ∆R ]. ∆1 +. j. ∆R2 ] ¯ [path. i. ∆In +. ∆]. ∆R ]. ∆R4 ] ¯ [path. ∆R2 ] | (∆R = ∆1 +. ∆2 −. ∆2 +. . A → α • Bβ. j]}. A → α • Bβ.

j]. [∆Ac1 . ∆I0 ]} DCompH = {[∆Ac1 . j] ∧ [pushC. ∆In . ∆I0 . i. ∆I0 ] [∆Ac1 . B → γ • . CL(∆)I0 . ∆2 −] ¯ DPath2 b = [pushC. A → α • Bβ. [pushC. A → αB • β. . ∆I0 −. B → γ • . [∆In −. [path2. ∆I0 . i. A → αB • β. k. k. [pushC. k. k. ∆1 +. A → α • Bβ. ∆In +. k] [∆Ac1 . i. ∆I0 . i. ∆I0 . i. k] [∆Ac . i. ∆2 −] ¯ [path2. ∆3 −] ¯ [path2. ∆I0 . ∆In . k] [∆Ac1 . ∆I0 +] [∆Ac1 . ∆In −. ∆Ac −. ∆3 −] DCompG = {[∆Ac . A → α • Bβ. ∆I0 . i. ∆2 −. A → αB • β. k]. [∆In −. A → α • Bβ. ∆In −. ∆1 +. B → γ • . j]. B → γ • . k] [∆Ac . i. ∆1 −. A → αB • β. [∆In +. i. j] } . j] } DCompF = {[∆Ac . ∆1 − . . A → αB • β. ∆In −. j]} ¯ DCompE = {[∆Ac −. ∆I0 ] |∆Ac > ∆In } ¯ DPath2 a = [pushC. ∆1 +]. . ∆I0 . j]. [∆In −. ∆In −. A → αB • β. RECOGNITION AND PARSING OF GILS [∆Ac +. j]} ¯ DCompD = {[∆I −. k. ∆1 −. ∆Ac2 −] [∆Ac2 −. ∆1 +]. j]. [path2. ∆I0 −] [∆Ac1 . ∆I0 +. ∆I0 . B → γ • . ∆I0 −. A → α • Bβ. ∆1 −. j]. j] ∧ [pushC. i. i. ∆2 −]. ∆I0 ] ¯ [∆In −.86 CHAPTER 5.

# ⇒ a1 . · · · . then prove that all ξ with d(ξ) = m. · · · . 1 ≤ i ≤ k. −p2 ).11 Proposition 7 (Invariant of the Path function) . It has to be shown that for all η1 · · · ηk ξ ∈ D with η i ∈ H ∪ W. PROOF OF THE CORRECTNESS OF THE ALGORITHM A correctness proof method for parsing schemata This method is deﬁned in [76] 87 • Deﬁne the set of viable items W ⊆ I as the set of items such that the invariant property holds. (y. The derivation length function is deﬁned according to the properties of the parsing algorithm. p1 ).5. Deﬁnition 13 (derivation length function ) 10 Let (P) be a parsing schema.. Because we introduced another class of items. to use in the induction proof. A function d : H ∪ W → N is a dlf if (i) d(h) = 0 for h ∈ H.. • Proof of soundness for all the deduction steps: V(P) ⊆ W. and π ∈ C ∗ . p2 > p1 ≥ p0 3. S. ξ ∈ V(P). (x.4.aj γ. IC EGIG . νx = µyπ such that y ∈ I. Show that all the viable items (all possible derivations are deduced by the algorithm). #νx for some γ ∈ N V ∗ and some ν ∈ (I ∪ I)∗ and x ∈ I. the items corresponding to the control language. 2. we need also an invariant for the computation of the control properties. This proof uses a so-called deduction length function (dlf ). η k ξ ∈ D such that {η 1 . p0 )] is valid for a string a1 · · · aj if and only if the following holds: ¯ ¯ 1. η k } ⊆ W and d(η i ) < d(ξ) for 1 ≤ i ≤ k. it holds that ξ ∈ W . : W ⊆ I a set of items. • Proof of completeness: W ⊆ V(P). Assume that any item η in W with derivation length less than m is obtained (if d(η) < m then η ∈ V(P)). In other words that the deduction steps preserve the invariant property. An item [path. (z. (ii) for each ξ ∈ W there is some η 1 .

.. b.. #ν for some γ ∈ V ∗ and some ν ∈ (I ∪ I)∗ . Let G = (N. A → αa • β.. • Case 1. P.(A → αaβ) ∈ P δ ∗ c. p0 ). #. For all η 1 · · · η k ξ ∈ D with η i ∈ H ∪ W.aj −1 .. p1 ).2. Regarding the pop items it is derived from the path function. V(P) ⊆ W.88 CHAPTER 5. I(z. for grammar G and input w and η i . n ≥ 0 where each ak ∈ T for 1 ≤ k ≤ n. then scan ηj ¯ a. • If η i is a correct item for grammar G and input w and η i η j then η j is a correct item. . Proof . η k are correct items. Scanner. µ y aj π π a j Figure 5.. I(z. # µ y x γ ρ . # ⇒ a1 . I... 1 ≤ i ≤ k it holds that ξ ∈ W This can be rephrased as follows in terms of the algorithm presented in section 5. α. η k item. p0 ).22: Path invariant Lemma 7 (GIG items soundness is preserved under Scan. η j then η j is a correct • If η i . i] is in S j if and only if η j −1 : [Ac(y. Let 0 ≤ i. A → α • aβ. S) be a GIG and let w = a1 · · · an . T. j ≤ n. correctness of the push items is straightforward. #νz µy π 10 From 11 The ∗ [76]. An item η j : [Ac(y. #νδ ⇒ ai+1 .ai Aγ. S. p1 ). (the invariant property) holds. RECOGNITION AND PARSING OF GILS S z S zy y a1 # x γ ρ a 1 . where correct means that the proposition 2. Predict Completer) . i] is in S j −1 and η j −1 Since η j −1 is correct.

4. S. x = y . δ = y . i] is in S j . the following derivations follow: η pop . δ = x ∈ I. (¯. p2 = j + 1 η ij predict η jj ∧ η push η push = [push. j] is in S j if and only if: η ij : [Ac(y. η push η path [path. p3 = j + 1. b. (x. (B → ξ) ∈ P such that δ Since η ij is correct. (z. (y. PROOF OF THE CORRECTNESS OF THE ALGORITHM ∗ 89 Now αaj . and we conclude the proof for Case1. This together with a...) and the following deduction steps apply according to the value of δ i. z ) ¯ . #νzµyπ y ¯ It should be noted also due to η pop is obtained in this derivation. #νzµyπ from η ∗ ij ∗ (a. . ij predict η jj ∗ . #νδ ⇒ ai+1 . allows us to conclude that η j is a correct item in S j . I(z. p0 )) e. p0 ). #νzµyπ from (B → ξ) ∈ P ii. u = y.aj . x .5. #νzµyπ y ⇒ ¯ ∗ . # ⇒ a1 . (y. α. ∗ ¯ a.(A → αBβ) ∈ P δ c. p0 )) y e. b. p3 = p0 . (B → ξ) ∈ P . #νzµyπ ⇒ x . p3 ).ai Aγ. #νzµy π Therefore: (this is common to all the subcases) d. A → α • Bβ. . u = x.. # ⇒ a1 · · · ai ai+1 · · · aj Bβγ. p2 ). u = y . Predictors An item η jj : [Ac(u.aj . η e. #ηδ ⇒ (ai+1 . #ν for some γ ∈ V ∗ and some ν ∈ (I ∪ I)∗ . p1 ). p3 = −p1 . and c. and c... y . S. p2 = −p1 ¯ ¯ ¯ η ij predict η jj ∧ η pop η pop = [pop. I(x. • Case 2.. #νzµyπx ⇒ y ¯ ∗ . δ = . p1 = p2 . B → • ξ. (z. #νzµyπx iii. j + 1). p1 ). (B → aξ) ∈ P . p1 ). x = cl(z). −p1 ). #νz µy π by b.

and c. z ]. i] is in S j if and only if an item η an item η kj : ik : [Ac(y. p3 < 0. y. z ]. I(z.ai Aγ. #νzµyπ x from (B → ξ) ∈ P ¯ δ such that #νzµyπ x = #ν xπ x from d. Therefore S. η push η path1 Case 3. (z. z). the same deductions as in the previous case are triggered: η pop . p0 )] where p is either push or pop. (x . p0 ). (¯. ¯ ¯ ¯ iv. z ] is correct. z ) such that x ∈ I and z is either z or z . η push η path η path2 by Dpath b η pop .. #νzµyπ from η . I(z. (B → ξ) ∈ P . #νzµyπ = #ν x π such that π ∈ C. p3 ). . B → ξ • . ¯ x η ij . Completer An item η ij : [Ac(y . p1 ). p2 = p3 . A → α • Bβ. i] is in S k and an item η p : [p. p2 ). ∆Ac1 . y. in the previous page) . (This item corresponds to the edges that relate the nodes in η ij and η kj Given η ik and η kj are valid items we obtain: ∗ ¯ a. p2 ). p1 ). z) and η push = [push. y ∈ I.90 CHAPTER 5. y . x . b. p1 ). p3 ). ¯ by Dpath a or η pop . η path2 = [¯. p0 )] x Since η path = [path. p0 ). abs(p3 )). η path predict η jj ∧ η pop η path ((y. y. u = x. z ) η pop = [pop. x. (y. x . k] is in S j and [Ac1(u. η path1 = [path. x ∈ I. η push η path1 η path2 by Dpath b where η pop = [pop. # ⇒ a1 . A → αB • β. (y. I1(x. x . x. p1 ). RECOGNITION AND PARSING OF GILS where η pop = [pop. δ = x . ¯ ¯ It should be noted also that as a consequence of η pop . I(z. then d. I1(x. S. x = x . −p3 ). z ). # ⇒ a1 · · · ai ai+1 · · · aj Bβγ. #νz µy πδ ⇒ ∗ ∗ ij (a. #ν for some γ ∈ V ∗ and some ν ∈ (I ∪ I)∗ .. abs(p3 )). y . ¯ ¯ ¯ y x. (x . η push = [push. y.

Those conditions are checked as follows according to the corresponding deduction step: A. prove that η j : [Ac(y.4. Both substrings are substrings of the Control language but their concatenation might not be. ηp Complete η ij (η kj initial node:+. therefore the Consequently the result subtree contains #ν xµ yπ = which is in the control language. B. η ik . η ik . p3 ). #νz µu πδ ∗ ∗ from (B → ξ) ∈ P δ f... η p Complete η ij (η ik is a transmitted item). α. η ik . p0 ) in η ik Ac(y.ak . active node:-) if and only if: . ⇒ ai+1 · · · ak ak +1 · · · . aj #νz µu πx µy π This derivation together with a. i] is a correct item in S j . x ∈ I and p2 ≥ p3 > 0 η pushC = [pushC. #ν x µy π ∗ c. k. ⇒ ai+1 · · · ak ξ. p0 ). (x. I(z.. η p Complete η ij ∧ η pushC (η kj has positive initial and active nodes) if and only if: y. η kj .. p2 ). p3 ) in η kj . p2 ).5. The individual properties of zµu and xµy are checked using the information stored at: Ac1(u. η kj . η p . #νδ ⇒ ai+1 .ak Bβ. the control language spans in positions i. αB. p1 ). #νδ ⇒ ai+1 . PROOF OF THE CORRECTNESS OF THE ALGORITHM b. We need to check the information in the corresponding nodes to validate the substring properties. #νz µu π for some (A → αBβ) ∈ P δ ∗ 91 from η ik and ⇒ ak +1 . #ν δ for some (B → ξ) ∈ P δ Now compose some of the pieces: d. The crucial step is checking the consistency of: #νzµuπxµ yπ in f.aj . p0 )] therefore given #ν (xµ (yπ is in the control language for some ρ then #νzµuπxµ yπ is also in the control language for some ρ C... η kj . #νz µu π e. (z. ξ. if and only if: z ∈ cl(i). A → αB • β. I(z. I1(x.

y = x. (¯. (¯. ¯ η path2 guarantees that the result is in the control language. p2 ). .) if and only if: x ∈ I. η p and π ∈ C.92 CHAPTER 5. (y. p3 = −p1 ¯ Result string: #νzµ(uπ u)µ y π which is equivalent to #νzµπ µ y π . p3 < 0. x ∈ I. (x. the initial node is a transmitted node. η ik . Therefore: #νzµuπ(xµ y)π = #νzµuπ(xµ x)µ y)π ¯ D. η kj . (z. abs(p2 ) ≤ abs(p0 ) x = u. p3 > 0. p3 > 0. η ik . p3 )] ¯ z. x ∈ I. p2 = −p3 . η kj . (y . η kj . y ∈ I. The current active node is negative). ηp Complete η ij ∧ η p 2 if and only if η p 2 = [popC. (x. ¯ Therefore #νzµuπ(xµ x)π = #νzµuπ ¯ E. (x. −p3 )] x x requirement that x has to be reduced. η kj . F. p1 ). η path2 Complete η ij ( x reduces u. RECOGNITION AND PARSING OF GILS ¯ x ∈ I. −p3 ). η ik . ηp Complete η ij if and only if x ∈ cl(DI). ηp Complete η ij ∧ η p if and only if: η p = [popC. abs(p2 ) < p3 η p = [popC. (x. (u. A reduction is performed. p3 < p2 Result is νzµuπx)µ y π G. if and only if: η p = [p. p3 ). p0 < 0. . p3 )] ¯ z ∈ I. Result is νzµuπx)µ y π H. η ik . p0 )] u η path2 = [path2. (¯. η p Complete η ij (xµ yπ is in C. p2 )]. η kj . p3 ). −p1 ). η ik .

# ⇒ a1 · · · ai Aγ. S. i] is inserted in the Set S j . A → α • β. It states that all the derivations in the grammar will have the corresponding item in the set of states. For each ξ ∈ W there is some η 1 · · · η k 1 ≤ i ≤ k. Completeness) .(x < y) +/ TARGET ITEM Ac1(u.4. #νzν yν } where δ = z if δ ∈ I ∪ I else δ = ∗ ξ ∈ D such that {η 1 · · · η k } ∈ W and d(η i ) < d(ξ) for such that #νzν yν satisﬁes the conditions imposed in proposition 2. α. If 1. PROOF OF THE CORRECTNESS OF THE ALGORITHM cl(x)µ y π = Therefore the result is νzµuπ 93 The following table 5. p1 ). Result x µy π #νz µu π(x µ (y π #νz µu π(x µ y )π . p1 ) I(z. p3 ) Ac(y. #ν 2. p0 ). (A → αβ) ∈ P δ ∗ ¯ 3. p0 ) cl(z µu π) = +/+/+/+/+ +/-.1 summarizes the conditions speciﬁed by the Completer Operations. #νδ ⇒ ai+1 · · · aj . ¯ µ = µ x )µ reduce: #νz µ u π ¯ #νz µ(u π u )µ y π reduce: #νz µ y π #νz µu πx )µ y π pushC(∆In .5. p2 ) +/+/+ –+ + – + -x=u ¯ cl(xµyπ ) = –: y=x ¯ +/. −) #νzµuπ +:u Table 5. . This lemma is equivalent to the following claim in terms of the algorithm presented in section 5. then an item ξ = [Ac(y. CASE A B C D E F G H COMPLETED ITEM I1(x.2 and Proposition 6. I(z.1: Conditions on the completer Deductions Lemma 8 (Second direction.

#ν ∧ δ. p1 ). I(z. and 3. #νδ ⇒ ai+1 · · · aj . #ν ⇒ ai+1 · · · aj . S. A → α • β. p1 ). I(z. #ν zν uν ⇒ γ. such that the invariant holds for those items previously introduced in the item set. #ν 2. 12 Notice that induction on the strict length of the derivation would not work. #ν zν uν xµyπ with minimal µ + ρ ¯ then if δ = x ∈ I ∪ I η = [Ac(u. #ν zν uν B. because of the Completer operation. i] Let 1. Therefore the derivation length function is the same as deﬁned by [76] as follows: d([Ac(y. p0 ). p0 ). A → α • aβ. α. d(η) = d(ξ) − 1 and ζ. p1 ). # ⇒ a1 · · · ai Aγ . p0 ). #ν µ λ π 12 ∧ } ⇒ ai+1 · · · aj . η ξ. ν zν yν • Scanner: ξ = [Ac(y. p0 ). The modiﬁcation of the Earley algorithm for GIGs does not modify the treewalk that the algorithm performs. p1 ). A → α • Bβ. p2 ). i. p0 ). A → αB • β. I(z. RECOGNITION AND PARSING OF GILS The proof by induction on the derivation length function d applied to the derivations speciﬁed in 1. # ⇒ δAγ. • Completers: ξ = [Ac(y. #ν zν uν δ ⇒ aj +1 · · · ak . i] is in S j . #ν ⇒ a1 · · · ai .94 CHAPTER 5. I(z. #ν . i] in S k Let S. (A → αβ) ∈ P δ ∗ 3. i] is in S j −1 and from ζ = [a. j] ∈ HGIG d(ζ) = 0. The derivation length function is based on the treewalk that the Earley algorithm performs. j − 1. #νzν yν ∗ ¯ } if δ ∈ I ∪ I else δ = Then η = [Ac(y. #ν α. α. #ν zν uν δ δ ρ µ ∗ and γ. . The conception of the derivation length function is similar to the kind of induction used by [39] on the order of the items to be introduced in the set S i . # ⇒ a1 · · · ai Aγ . j]) = min{π + 2λ + 2µ + j | S. A → αa • β. I(z.

ζ ξ • Predict: ξ = [Ac(y. η. I(z. γ . p0 )] d(η) = d(ξ) − 1 = d(η p ) . #ν ⇒ a1 · · · ai . (u. (x. η . p1 ). p1 ). η . η. p1 ). p0 ). ζ = [Ac(y. p3 ). p0 )] such that p = push or p = pop. (y. #ν and let δ. p3 ). j] is in S k and d(η) < d(η ) < d(ζ) = d(ξ) − 1. I(cl(z). B → γ • . (u. p1 ). j] η η ξ if δ = ξ ∧ ηp and η p = [p. p1 ). π. #ν ⇒ αBβ. p3 ). j] in S j Let S. (z. (z. #ν and A. p0 )] such that p = push or p = pop. λ. ν zν yν µ } with π + 2λ + 2µ minimal. I(x. #ν . (δ. p1 ). η . A → α • Bβ. j] is in S k and d(η) < d(ζ) = d(ξ) − 1. p0 ). ζ = [Ac(y.5. ζ ξ if δ = and xµyπ = η = [p. δ. µ such that S. p0 ). η. Then η = [Ac(y. (z. B → • γ. I(z. p3 ). B → γ • . (x.4. PROOF OF THE CORRECTNESS OF THE ALGORITHM η = [p. I(x. #ν δ ⇒ ai+1 · · · aj . p3 ). p2 ). B → γ • . #ν δ δ λ π ∗ α. # ⇒ a1 · · · aj Bγ . p2 ). ζ if δ = ξ 95 and xµyπ = ζ = [Ac(u. # ⇒ δAγ . j] is in S k and d(η) = d(η ) − 1 < d(ζ) = d(ξ) − 1.

the prototype is not particularly eﬃcient. Repeat the following steps until the agenda is exhausted: (a) Select an item from the agenda. if necessary. Items should be added to the chart as they are proved. called the trigger item. Those new potential items are triggered by items added to the chart. its consequences are computed and themselves added to the agenda for later consideration. and remove it. each new item may itself generate new consequences. the inference engine provides the control and data types.5 Implementation In order to perform some tests and as a proof of concept. 5. . However. Initialize the chart to the empty set of items and the agenda to the axioms of the deduction system. and Lemma 8 W ⊆ V(P). (b) Add the trigger item to the chart. chart-based deduction procedure is as follows (from [72]): 1. 2. However. When an item is removed from the agenda and added to the chart. we have proved the correctness of the Parsing Schema V(P) = W. the parsing algorithm described in section 5. The chart holds unique items in order to avoid applying a rule of inference to items to which the rule of inference has already applied before. Any new potential items are added to an agenda of items for temporarily recording items whose consequences under the inference rules have not been generated yet. This is performed using the subsumption capabilities of prolog: those items not already subsumed by a previously generated item are asserted to the database (the chart). the relation between the abstract inference rules described in the previous section as parsing schema and the implementation we used is extremely transparent. Because the inference rules are stated explicitly. agenda-based inference engine described in [72].2 was implemented in Sicstus Prolog on top of a general-purpose. Given that the parsing schema abstracts from implementation details of an algorithm. as a meta-interpreter.96 CHAPTER 5. The general form of an agenda-driven. The Prolog database is used as a chart which plays the same role as the state sets in Earley’s algorithm. RECOGNITION AND PARSING OF GILS Therefore from Lemma 7 ( V(P) ⊆ W). Encodings of the parsing schema as inference rules are interpreted by the inference engine.

In this implementation the control language was not represented by separate items but as side conditions on the inference rules. b. The axioms correspond to the initial item in the Parsing Schema: DInit = { [(#. • Grammar Gamb5b which generates aacdbbcd and aadcbbdc but does not generate aacdbbdd nor aacdbbdc (a variation of Gamb5 presented above). {an bn cn dn |n ≥ 1}. {ww|w ∈ {a. and add these generated items to the agenda. b}∗ } • {w(cw)+ |w ∈ {a. c}∗ and |a|w = |b|w = |c|w ≥ 1} Critically the most demanding was the mix language due to the grammar we chose: Gmix presented in chapter 2. generate all items that are new immediate consequences of the trigger item together with all items in the chart. w ∈ {a. b}+ } {an (bn cn )+ |n ≥ 1}. 0]} and the encoding of the input string. S → • S$. 0. 0). 0. otherwise it is not. b}+ } • Grammar Gamb4 which generates aabbcdcd but does not generate aabbcddc nor aabbdccd. {an bn cn de n |n ≥ 1}. • The mix language {w|w ∈ {a. If a goal item is in the chart. n]}. The number of items generated for the Mix and the copy languages were as follows: . 0). (#. 3.5. 0). IMPLEMENTATION 97 (c) If the trigger item was added to the chart. 0). (#.5. S → S • . This grammar has a high degree of ambiguity. which where performed by procedures which implemented the path function over the graph representation. Tests on the following languages were performed: • {an bn cn |n ≥ 1}. {an bn cm dm en f n g m hm in j n |n ≥ 1} • {an bn wwcn dn |n ≥ 1. the goal is proved (and the string recognized). • {an bn cm dm en f n g m hm |n ≥ 1}. The goal corresponds to the ﬁnal item in the Parsing Schema: F EGIG = {[(#.

500 ≈ 2.736 50. An item A → β 1 • β 2 is valid for a viable preﬁx αβ 1 if there is a derivation S ⇒ αAw ⇒ αβ 1 β 2 w. The set of preﬁxes of right sentential forms that can appear on the stack of a shift-reduce parser are called viable preﬁxes in context free LR-parsing. ≈ 300 ≈ 1. We will refer to the connections between Earley parsing and LR parsing to clarify this presentation. RECOGNITION AND PARSING OF GILS n4 1296 10.000 ≈ 16. In the GIG case.100 ≈5. We will do this in such a way that the set of items contain information not only of what possible items belong to the set but also of the possible indices that might be associated to the set of parsing conﬁgurations that the items describe.625 104. We say a GIG item index pair [ δ..ai Aβ ⇒ δγ j a1 . A → β 1 • β 2 ] where δ is in I ∪ {#} is valid for a viable GIG µ preﬁx αβ 1 if there is a derivation using the GIG context free backbone: S ⇒ αAw⇒ αβ 1 β 2 w and there is a GIG derivation S ⇒ γ i a1 . The sets that deﬁne the states in GIG LR parsing are composed by a pair of sets (IT.000 ≈ 28. the technique we present here converts an LR GIG into a deterministic LR-2PDA according to the deﬁnition presented in Chapter 2.100 MCopy L. [41].6 LR parsing for GILs An LR parser for a CFL is essentially a compiler that converts an LR CFG into a DPDA automaton (cf. We use this notion of viable preﬁxes to describe the computation of the rm rm ∗ main stack in a LR-2PDA. This approach can be extended to a Generalized LR parsing approach.800 5. 5.6. if multiple values are allowed in the parsing table (cf. [2]).000 Copy L. ≈ 100 ≈ 400 ≈ 700 ≈ 1.. The similarities of Earley Parsing and LR parsing are made explicit in those transformations.000 20.000 ≈6.1 LR items and viable preﬁxes We assume the reader has knowledge of LR parsing techniques (cf. It is also more complex because GIL derivation requires leftmost derivation for the stack operations. IN ). [80]). ≈ 500 ≈ 2.aj β 2 β..98 Length 6 9/10 12 15/16 18 CHAPTER 5. ∗ ∗ rm rm ∗ .976 Mix L.500 ≈2.000 ≈ 9. Both [75] and [3] describe transformations of Earley Parsing Schemata to LR Parsing Schemata. The notion of valid items for GILs is more complex because a GIG LR-item has to encode the possible conﬁgurations of the auxiliary stack.. Therefore the set of items has to encode the corresponding top-down prediction that aﬀects the stack of indices. [2]).

[3]).The transitions of this NFA are of the following form: δ(A → α • Bβ. Such productions are considered in case 2 of the Goto function. . the goto function and the parsing table. They are also determined by the Goto operation. then closure(IT ) is the set of items constructed from IT by the two rules: 1. R → Rb ¯ j The set of states for the grammar Gwcw should encode the possible conﬁgurations of the stack of indices as follows: . S. S → cR 6. {a. R → Ra ¯ i 5.5.6. ) |B → γ is a production } (a PDA transition) ¯ ι ¯ ι It is apparent that the two items should not be conﬂated because there is a change in the stack conﬁguration. Initially. The following example uses a grammar for the language Lwcw to depict the construction of the set of items. every item in IT is added to closure(IT ). or (ii) µ δ B → aγ then add the item B → • γ (case 1) or the item B → • aγ (case 2) to IT if it is not δ δ δ already there. if the index operation is for instance ¯: ι δ(A → α • Bβ. ) = {B → • γ |B → γ is a production } (a NFA transition) In the GIG case the transitions should be as follows. S → aS i 2. P ) and P is: 1. The Closure operation is equivalent to the Predict function in Earley parsing (cf. Gwcw = ({S. j}. R}. {i. Example 21 L(Gwcw ) = {wcw |w ∈ {a. For the GIG algorithm the set of items and possible index values cannot be determined only by the Closure operation. However in Earley’s algorithm this computation is done in run-time while in LR parsing it is precompiled in the LR states. ι) = {(B → • γ.2 The Closure Operation. LR PARSING FOR GILS 99 5. R → [#] 4. b}. [41]) the Closure operation is equivalent to obtaining the set of states of a NFA that recognizes the viable preﬁxes. If IT is a set of items for a grammar G.6. Apply this rule until no more new items can be added to the closure of IT . If A → α • Bβ is in closure(IT ) and (i) B → γ is a production where δ is in I ∪ { }. #. 2. ¯ Note that the two conditions of the Closure operation rule out the possible index operations δ and [δ] when the right-hand side of the production starts with a non-terminal. b}∗ }. For CFG parsing (cf. S → bS j 3.

ι) = (I j .6. #} {i. then goto(I. is the set of items that are valid of the viable preﬁx-index pairs (γX. RECOGNITION AND PARSING OF GILS I1 : i S → a•S i i I2 : j S → b•S j i I3 : I4 : I5 : I6 : I 10 : {i. We will describe the Goto function adding the possibility of computing the possible stack values of the PDA for each state. In the GIG case. X. X).100 I0 : # S → •S S → • aS i CHAPTER 5. The operation goto(IT. 5. #} {i.23: Set of States for Gwcw In the same way that the dot implies that some input symbols have been consumed.3 The Goto Operation. X) is the set of items that are valid for the viable preﬁx γX. Intuitively. the new sets I4 and I5 (as compared to context free sets) imply that an index i or j has been consumed from the stack.ι). The CF function goto(IT. then goto(I. the Goto function in the GIG case is a PDA and the set of viable preﬁxes with associated indices is a context-free language. X. s) is in IN . j. The CF Goto function is a DFA transition function where IT is in the state set and X is in the vocabulary. is deﬁned to be the closure of the set of all items [A → αX • β] such that [A → α • Xβ] is in IT . The GIG function Goto has three parameters a) IT is a set of items b) X is a grammar symbol and c) IN is a set of pairs (i. if I is the set of items that are valid for some viable preﬁx-index pairs (γ.IN 2 ) where either 1 or 2 applies: . #} # # S → c•R R → • Ra R → • Rb ¯ j ¯ i S → • aS S → • bS j S → • aS S → • bS j S → • bS j S → • cR I7 : I 11 : # # S → aS • j S → • cR I8 : I 12 : # # S → bS • j S → • cR I9 : I 13 : # # S → cR • j R→ • [#] R → R•a ¯ i R → R• b ¯ j R → Ra • ¯ i R → Rb • ¯ j Figure 5. j. We will say an index i is in IN if (i. The set I6 requires that the stack be empty. ιj ).ιj ) in other words. j. if µ µ I is the set of items that are valid for some viable preﬁx γ. s) where i is an index symbol and s is a state deﬁned by a set of items closure. where IT is a set of items and X is a grammar symbol. IN ) is deﬁned to be the pair (IT 2 .

(e.: i indicates a push. IT i ) in IN [B → [δ] • β] such that [A → α • Bβ] is in IT and δ is in IN and IN 2 is deﬁned such that every µ (δ. ¯ indicates a pop. The ﬁrst element of the pair is the symbol X and the second indicates the operation on the PDA stack (e. the possible values are: a) pairs of shift action and operations on the auxiliary stack: push. IT 2 ) is in IN 2 and IN is in predecessor(δ. IN ) is deﬁned to be: β] such that [A → α • Bβ] is in IT and δ is in IN and IN 2 is deﬁned such that µ predecessor(δ. [A → a • β] is in IT 2 ): µ If µ is δ in I then (δ. LR PARSING FOR GILS 1. IT i ) is in IN 2 for every (δ. IT i ) is in IN 2 .g. IT 2 is the closure of the set of all items [A → αX • β] such that [A → α • Xβ] is in IT µ µ 101 and IN 2 is deﬁned to be the set of indices with an associated state such that: Case A: α is and X is a terminal a (i. µ In other words.g. . [A → αa • β] is in IT 2 ) µ When the second parameter of the Goto function is 2. The construction of an LR parsing table is shown in the following algorithm. the auxiliary stack has the conﬁguration corresponding to the completed item B.5. state. The construction of the collection of sets of items for a GIG grammar is made following the algorithm used for context free grammars. IT i ) in IN is in IN 2 ¯ If µ is δ and δ is in IN then predecessor(δ. Case C: If α is not X is a terminal a then IN = IN 2 (i. [2]).6. IT 2 is the closure of the set of all items [B → ¯ δ • then goto(IT. IT i ) in IN is in IN 2 The Goto function for the grammar Gwcw is depicted in ﬁgure 5. IT 2 ).24 with a PDA.e. The only changes are those made to the Closure and Goto operations as described above. The indices associated in each state are those indices that are represented also in ﬁgure 5. . If µ is then IN is in IN 2 If µ is [δ] and δ is in IN then every (δ. The action table has three parameters.e. Case B: If X is a non-terminal B then IN 3 is in IN 2 such that [B → γ • ] is in (IT 3 . [#] indicates a transition that requires an empty stack and indicates that i the content of the stack is ignored).23. IN 3 ). input (or ) and auxiliary stack.

i ) i. annotated with indices for the grammar Gwcw pop or none. ε ) (b. i) (c. ε ) i. [δ].j. δ.j) (b. RECOGNITION AND PARSING OF GILS (a. δ is an index and µ is either δ. j ) (ε . ε ) (S.# I3 (ε . b) reduce action (in this case no operation on the auxiliary stack is performed).j.j) to I 2 to I 3 # I7 (c. ε) # I 12 ( ε. ε ) ( ε . ε ) (ε .# I4 (R. i ) (R.[#]) # I6 (R.j) j I2 (a . ε ) # I9 Figure 5. β is a possible empty sequence of non terminals and ¯ terminals. The Goto table has the usual properties.102 (a. ε) to I 1 to I 3 # I8 (ε . i ) (c. . B) denote non-terminals lower case letters (a) terminals.ε ) # I 13 (ε .24: Transition diagram for the PDA recognizing the set of valid preﬁxes.i) (b.#) # I 10 to I 6 (a.i) # I0 i I1 CHAPTER 5. j ) (ε .#) # I 11 to I 6 i. ε ) (S. α is a non empty sequence of non terminals and terminals.# I5 (b.j ) ( ε. The notation used is a follows: capital letters (A.j. and no operation on the auxiliary stack.

then ¯ δ set action[i. #] to “accept” If any conﬂicting actions are generated by the above rules.5.. d. . IN j ). IN j ). b. where A may not be S . . Here a must be a terminal. The parsing actions for state i are determined as follows: a. g. then ¯ δ set action[i. i. and δ is in IN i and IN j [δ] then set action[i. . If [A → • aβ] is in I i and goto(I i . Output. Here a must be a terminal and α must be non-empty. a. δ] to (shift j. adding the additional stack to compute the corresponding actions depicted in the table. f. If [A → β • ] is in I i . 3. a. a. ] to (“shift j”. then set action[i. and δ is in IN j . IN i ) = (I j . then goto[i. a. If [S → S • ] is in I i then set action[i. IN j ). a. a. “pop δ”). a. h. IN i ) = (I j . The SLR parsing table functions action and goto 1. IN j ). ] to “reduce A → α” for all a in µ µ FOLLOW(A). A. inj ] = j. “push δ”). An augmented GIG grammar G’. IN i ) = (I j . IN i ) = (I j ..6. and δ is in IN i and IN j then [δ] set action[i. a. the initial state of the parser is the one constructed from the set of items The output transition table for the grammar Gwcw is shown in ﬁgure 5. IN j ). δ] to (shift j. IN j ).. we say the grammars is not SLR(1). 4. a. then set action[i. This table is used with an obvious extension of the context free algorithm. IN i ) = (I j . Here B must be a non-terminal. I 1 . δ] to (“shift j”. then µ set action[i. and δ is in IN i . δ] to (“shift j”.2. $. -). If [A → • Bβ] is in I i and goto(I i . IN i ) = (I j . . IN j ). IN i ) = (I j . then δ set action[i. but it is GLR(1). Construct C = {I 0 . ] to (“shift j”. 2. for every index in IN j .-).). State i is constructed from I i . Here a must be a terminal. and δ is in IN i . . If [A → α • aβ] is in I i and goto(I i . The goto transitions for state i are constructed for all non-terminals A using the rule: If goto(I i . ] to (“shift j”. a. “pop δ”). IN j ). If [A → • aβ] is in I i and goto(I i . If [A → • aβ] is in I i and goto(I i . a. LR PARSING FOR GILS 103 Algorithm 7 (Constructing an SLR parsing table) Input. e. I n }. IN i ) = (I j . If [A → • Bβ] is in I i and goto(I i . the collection of sets of LR(0) items for G . Here B must be a non-terminal. If [A → • aβ] is in I i and goto(I i . -). . . A. c.

(s3. ) ) ) ) ( . ) (s1.#) 14 7 8 9 10 11 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (a. p j) (c. p i) (b.#) (R. pop) (s4.#) ($.104 State CHAPTER 5. ) (s13. pop) (s4.i) Goto (S. p i) (s1.#) (s4. p j) (s2. pop) (s6. pop) (s5. .j) ( . RECOGNITION AND PARSING OF GILS Action ( . (s3. ) r4 r5 acc Table 5. pop) r6 r6 (s5. (s3. ) r6 r1 r2 r3 (s12. ) (s6. p j) (s2. ) (s6. p i) (s1. ) (s2. The only diﬀerence is that it takes into account the operations on the auxiliary stack. pop) (s5. We follow the notation from [2].2: Action/Goto Table for Gwcw The parsing algorithm for GIGs is essentially the same algorithm for CFGs.

Output. a. Input. i] = accept then return else error end The following table shows the moves of the LR parser on the input string abcab. i] = reduce A → β then begin pop 2 ∗ |β| symbols from Stack1. i] on top of Stack1 output the production A → β µ 105 else if action [s. else if action [s. push A then goto[s . A.5. An input string w and an LR parsing action − goto table for a grammar G. a. i] = shift (s . ) then begin push a then s on top of the Stack1 advance ip to the next input symbol. . pi )then begin push a then s on top of the Stack1 push i on top of Stack2 . If w is in L(G). Set ip to point to the ﬁrst symbol of w$. . else if action [s. else if action [s. (i ∪ )] = shift (s . pop) then begin push a then s on top of the Stack1 pop i from Stack2 advance ip to the next input symbol. let s be the state now on top of the stack. a. advance ip to the next input symbol.6. LR PARSING FOR GILS Algorithm 8 (LR parsing for GIGs) . repeat forever begin let s be the state on top of the Stack1 and i the symbol on top of the Stack2 a the symbol pointed by ip. if action [s. Initiate Stack1 with s0 . Initiate Stack2 with #. i] = shift (s . (i ∪ )] = shift (s . a parse for w otherwise an error indication. a. pop) then begin push a then s on top of the Stack1 pop i from Stack2 else if action [s. a.

106 CHAPTER 5.3: Trace of the LR-parser on the input abcab and grammar Gwcw . RECOGNITION AND PARSING OF GILS 1 2 3 4 5 6 7 8 9 9 11 12 13 14 15 16 Stack 1 0 0a1 0a1b2 0a1b2c3 0a1b2c35 0a1b2c354 0a1b2c3546 0a1b2c354R10 0a1b2c354R10a 0a1b2c35R11 0a1b2c35R11b 0a1b2c3R9 0a1b2S8 0a1S7 0S14 - Stack2 # #i #ij #ij #i #i # # # # # # # # # # Remaining input abcab$ bcab$ cab$ ab$ ab$ ab$ ab$ ab$ b$ b$ $ $ $ $ $ $ Comments Initial ID Shift and push Shift and push Shift Shift and Pop Shift and Pop Shift Reduce by 6 Shift Reduce by 4 Shift Reduce by 5 Reduce by 3 Reduce by 2 Reduce by 1 Accept Table 5.

They also oﬀer additional descriptive power in terms of the structural descriptions they can generate for the same set of string languages. Though this mechanism looks similar to the control device in Linear Indexed Grammars . In this section. we review some of the abstract conﬁgurations that are argued for in [29]. GIGs oﬀer additional descriptive power as compared to LIGs (and weakly equivalent formalisms) regarding the canonical NL problems mentioned above. at the same computational cost in terms of asymptotic complexity. The goal of this section is to show how the properties of GILs are related to the peculiarities of the control device that regulates the derivation. 107 . However those dependent paths are not obtained by encoding the dependency in the path itself. because they can produce dependent paths1 .Chapter 6 Applicability of GIGs 6. Similar approaches are also presented in [82] and [44] (see [56] concerning weak and strong generative capacity). the formalisms diﬀer in the kid of trees they generate. His discussion is addressed not in terms of weak generative capacity but in terms of strong-generative capacity. 1 For the notion of dependent paths see for instance [82] or [44].1 Linear Indexed Grammars (LIGs) and Global Index Grammars (GIGs) Gazdar [29] introduces Linear Indexed Grammars and discusses their applicability to Natural Language problems.

< an .i] C [] push pop Figure 6. >⇒< a1 . S. L. w1 > . APPLICABILITY OF GIGS 6.... In other words. P ).2 and 6. ai ∈ T ∪ { }.1 at the left.1.. In other words. CFGs cannot generate the structural descriptions depicted in ﬁgures 6. B [. and C is a control set deﬁned by a CFG (a Dyck language): {a1 . wn >.1. δ is in C } ¯ C is deﬁned to be the Dyck language over the alphabet I ∪ I (the set of stack indices and their complements). but every substring encoded in a spine has to belong to the control set language. It is easy to see that no control substring obtained in a derivation subtree is necessarily in the control language.1 at the right.108 CHAPTER 6. Those control strings are encoded in the derivation of each spine as depicted in ﬁgure 6. the control of the derivation can be distributed over diﬀerent paths.3.2 The palindrome language CFGs generate structural descriptions for palindrome languages (e.. G = (N. [87]). however those paths are connected transversely by the leftmost derivation order.an | < S. the control strings wi are not necessarily connected to each other.. and every possible spine is independent. where G is a labeled grammar (cf. the language {wwR |w ∈ Σ∗ }) only of the nested (center embedded) sort. T. Gazdar suggests that the conﬁguration in ﬁgure 6.] B ∗ ∗ A B pop push C A [] B [..1 Control of the derivation in LIGs and GIGs Every LIL can be characterized by a language L(G.. (we follow Gazdar’s notation: the leftmost element within the brackets corresponds to the top of the stack). Those control words describe the properties of a path (a spine) in the tree generated by the grammar G. C).1: LIGs: multiple spines (left) and GIGs: leftmost derivation 6. . as is depicted in the ﬁgure 6.2 would be necessary to represent Scandinavian . C): {w | S. wn ∈ C}.g. w1 . #δ and w is in T ∗ . We gave an alternative deﬁnition of the language of a GIG in chapter 5 to be the control language: L(G. # ⇒ w..

¯ Gadj = ({AP..b.3) cannot be generated by a GIG because it would require push productions with a non terminal in the ﬁrst position of the right-hand side.4 at the left. LINEAR INDEXED GRAMMARS (LIGS) AND GLOBAL INDEX GRAMMARS (GIGS) 109 [.a] [a] [.. (i.] a b c d d c b a Figure 6. {a. {i.a] [d.3: Another non context-free structural description for the language wwR However GIGs generate a similar structural description as depicted in ﬁgure 6.b. A.a] [c.2: A non context-free structural description for the language wwR unbounded dependencies. AP.a] [c.] [a] [b.b.a] [b.1. The corresponding structural description is shown in ﬁgure 6. b.4: Example 22 (Comparative Construction) . N P.a] [c. A}.a] [c. P ) where P is: AP → AP N P A→a i ¯ j ¯ AP → A A→c k ¯ ¯ A→AA NP → a NP ¯ i A→b j NP → b NP NP → c NP ¯ k .c.6..e.. the structure of ﬁgure 6. [. #.c.a] [d. in productions that are not in Greibach Normal Form).b. The English adjective constructions that Gazdar uses to motivate the LIG derivation are generated by the following GIG grammar. j}.e. c}.] Figure 6.] [a] a b c d d c b a [b. But the exact mirror image of that structure.b.b. In such structure the dependencies are introduced in the leftmost derivation order. Such an structure can be obtained using a GIG (and of course an LIG). (i.a] [a] [.a] [b.

b.b.c] [c.] NP NP c NP [.] A [b. as in the LIG case. 6. The structural description at the left can be generated by a GIG.b.c.] AP AP AP [.6 at the left.] a b c d a b c d [b.b..c..4: GIG structural descriptions for the language wwR It should be noted that the operations on indices are reversed as compared to the LIG case shown in ﬁgure 6. but not the one at the right.] A NP b [c] [a] [b.a] [c.d] [d] [.c.5: Two LIG structural descriptions for the copy language Gazdar further argues that the following tree structure.5)..b. On the other hand.a] [a] [.3. However..a] c d d a [b..] [a] a b c d [c.b.d] a [b.a] [b..a] [. a similar one can be obtained using the same strategy as we used with the comparative construction. the introduction of indices is dependent on the presence of lexical information and its transmission is not carried through a top-down spine.a] [c.a] c A A [a.a] [d.] a A a b [. could . APPLICABILITY OF GIGS [.110 CHAPTER 6.] [b.] [.b.1.c..c] NP [d.b.a] [a] [b.c.d] [c..d] [c.a] [a.d] b [d] c d Figure 6. shown in ﬁgure 6.. [..c] a b A c [c] b Figure 6. The arrows show the leftmost derivation order that is required by the operations on the stack.3 The Copy Language Gazdar presents the following two possible LIG structural descriptions for the copy language (depicted in ﬁgure 6.] NP AP [.

b. where the arrows depict the leftmost derivation order.b.b.b.7: A GIG structural description for the multiple copy language .a] [b.c.d] [a.a] [c.d] [b.a] a b c d [c. corresponding to the grammar shown in example 10.a] [c.d] [c.a] [d.b.a] [d.a] [a.1.a] [c.b.a] [b.c.b.b.d] b c [d] d [b.a] b c d ε a Figure 6.a] [a] a b a c [b.a] d c b [c.c.c.b.b. [] [a] [b. Such structure cannot be generated by a LIG. but they can generate the one presented in the ﬁgure 6.b.d] [b.a] [a] [d.c.a] c [a] b [] a [d.c.c.b.d] [d] [d. but can be generated by an IG.a] [c.c.6.c.a] [a] [a] [] [b.c. [d] [c.b.b. GIGs can also produce similar structural descriptions for the language of multiple copies (the language {ww+ | w ∈ Σ∗ } as shown in ﬁgure 6.b.a] [b.6 at the left either.6 (right).a] [b. LINEAR INDEXED GRAMMARS (LIGS) AND GLOBAL INDEX GRAMMARS (GIGS) 111 be more appropriate for some Natural Language phenomenon that might be modeled with a copy language.a] [a] [] [d.b.d] a b c d [c.b.c.d] [] [d.c.c.d] [a.b.a] c d d [c.a] [c.a] ε a d [b.a] [d.a] [a] a [] b Figure 6.c.b.7.6: An IG and GIG structural descriptions of the copy language GIGs cannot produce the structural description of ﬁgure 6.

The following language cannot be generated by LIGs.i] [i] d [. as we show in ﬁgures 6.] b Figure 6. {a. The relevant structures that can be produced by a LIG are depicted in ﬁgures 6.. e.9 (left).] [i..1. R.10 (at the right).11. #.4 Multiple dependencies Gazdar does not discuss of the applicability of multiple dependency structures in [29].] [..8 and the somehow equivalent in 6.] [i] a a [i.] [i] [.] c c Figure 6.8: LIG and GIG structural descriptions of 4 and 3 dependencies [.. It is mentioned in [82] in relation to the deﬁnition of composition in [79] Categorial Grammars. Gsum = ({S.] c c b [i. d.i] d [i] b b [.... P ) where P is: .i] [i] c c d [. [. L(Gsum ) = { an bm cm dl el f n | n = m + l ≥ 1}.] c [i] [i.9 (right).. GIGs can generate the same structures as in 6.i] [i..10 and 6. which permits composition of functions with unbounded number of arguments and generates tree sets with dependent paths.i] d [i] b c d a a [i] b b [.9: A LIG and a GIG structural descriptions of 3 dependencies GIGs can also produce other structures that cannot be produced by a LIG. L}. The corresponding structure is depicted in the ﬁgure 6. c. Example 23 (Dependent branches) . F.112 CHAPTER 6. b. {i}..] d [. f }. APPLICABILITY OF GIGS 6. S.] [i.8 and 6.i] b [.

.11: GIG structural descriptions of 3 dependencies 6..i] a b b c [i] [.i] a c c [.6.i] [i.] c [i] a [i.i] f [. ..] [..10: GIG structural descriptions of 4 dependencies [.] c [i..i] [i.i] b [i] [i] c [.] [.1. GIGs can produce crossing dependencies with some alternative structures as depicted in the following structures.1..i] [i] a [i..] [i] a f [i.i] a [i] [i] [i.] d d ε b Figure 6.5 Crossing dependencies Crossing dependencies in LIGs and TAGs have the same structural description as the copy language. The ﬁrst example is generated by the grammars Gcr presented in Chapter 3 and repeated here.] d [i] a c d b d e Figure 6.i] [i. LINEAR INDEXED GRAMMARS (LIGS) AND GLOBAL INDEX GRAMMARS (GIGS) 113 S → aSf |R i R→F L|F |L F → b F c |b c ¯ i L → d L e |d e ¯ i The derivation of aabcdef f : #S ⇒ i#aSf ⇒ ii#aaSf f ⇒ ii#aaRf f ⇒ ii#aaF Lf f ⇒ i#aabcLf f ⇒ #aabcdef f [.] [i] a [..] [i..

The following kind of dependencies can be obtained: Example 25 (Crossing Dependencies 2) . #. S. f. where Gcr8 = ({S. P ) and P is: S→AL A→aAf |aBf x B → b B e| b Ce x ¯ C → c C d| c d y L → g L h| g h y ¯ [i] a a b [ii] [i] [] e f f g g [k] h [] h b c [k] e d [kk] c d . e. L(Gcr8 ) = {an bn cm dm en f n g m hm | n. S. m ≥ 1}. B. h}. where Gcr = ({S. c. A. B → b B | b x D→dD|d x ¯ [] [ii] [] a a a b [ii] b b [iii] [i] c [] c c d d d [i] [] Additional number of crossing dependencies can be obtained (pairs or triples). C}. P ) and P is: S→AD A→aAc|aBc 3. b. d. y}. {a. CHAPTER 6. g. d}. {x}. m ≥ 1}. B. {a. A. APPLICABILITY OF GIGS L(Gcr ) = {an bm cn dm | n. {x. #. b. c.114 Example 24 (Crossing Dependencies) . C}.

c2 . C. b1 . m ≥ 1} 1 2 1 1 2 2 2 1 The language Lcrm is generated by the following GIG: Example 26 (Crossing Dependencies 3) . a ∈ T and γ ∈ (N ∪ T )∗ : • A[.2 Set Inclusion between GIGs and LIGs The last section showed similarities and diﬀerences between LIGs and GIGs in terms of the structural descriptions. B.2. B ∈ N. S. SET INCLUSION BETWEEN GIGS AND LIGS 115 Such structures might be relevant to be able to generate the following language(discussed in [86]). y}.6. related to the operation of generalized composition in CCGs. we could proceed as follows. Gcrm = ({S. d1 ... L2 }.] → a B[. A. D. In this section we are going to address the issue of whether LILs and GILs are comparable under set inclusion. b2 . If an equivalence between LIGs and LIGs with push productions in GNF could be obtained. a2 . Lcrm = {an am bn cn bm cm dm dn |n. L. {x. {a1 . d2 }. P ) and P is: S→AL x ¯ A → a1 A B 1 | a1 A2 B 1 L2 → C D A2 → a2 A2 y y ¯ B 1 → b B| b x L → c1 L d1 | c1 L2 d1 D → d2 d2 y ¯ C → b2 C C 2 | b2 C 2 C 2 → c2 C 2 y The derivation of a1 a1 a2 a2 a2 b1 b1 c1 c1 b2 b2 b2 c2 c2 c2 d2 d2 d2 d1 d1 S ⇒ AL ⇒ #a1 AB 1 L ⇒ #a1 a1 A2 B 1 B 1 L ⇒ yyy#a1 a1 a2 a2 a2 B 1 B 1 L ⇒ xxyyy#a1 a1 a2 a2 a2 b1 b1 L ⇒ yyy#a1 a1 a2 a2 a2 b1 b1 c1 c1 CDd1 d1 ⇒ #a1 a1 a2 a2 a2 b1 b1 c1 c1 b2 b2 b2 C 2 C 2 C 2 Dd1 d1 ⇒ yyy#a1 a1 a2 a2 a2 b1 b1 c1 c1 b2 b2 b2 c2 c2 Dd1 d1 ⇒ #a1 a1 a2 a2 a2 b1 b1 c1 c1 b2 b2 b2 c2 c2 c2 d2 d2 d2 d1 d1 ∗ ∗ ∗ ∗ ∗ ∗ 6. c1 . #. Our conjecture is that LILs are properly included in GILs. A2 . LIGs and Greibach Normal Form The deﬁnition of GIGs requires push productions in Greibach Normal Form. Deﬁnition 14 A LIG is in push Greibach Normal Formal if every push production is in Greibach Normal Form (where A.i] γ .

Then L(G) = L(G1 ).γ i ] → αi B[.4 in [41] as follows also holds for LIGs and it would allow to transform left recursion into right recursion.]β 1 |β 2 | · · · |β r be the set of all B-productions (they do not aﬀect the stack).. Let G1 = (N ∪ {B}. Lemma 10 Deﬁne an A − production to be a production with variable A on the left.γ 1 ]α1 |A[. Let G = (N. Let A[. A[. B[. An adaptation of the lemma 4. S) be obtained from G by deleting the production A → Bα2 from P and adding the productions A → β 1 α2 |β 2 α2 |β r α2 . T. T. the proper inclusion of LILs in GILs would be obtained: • For any LIG there is an equivalent LIG in push-Greibach Normal Formal... Let A[. APPLICABILITY OF GIGS Lemma 9 For any LIG in push-Greibach Normal Formal there is an Equivalent GIG that generates the same language...γ i ] → β i B[.] → A[.γ r ]αr be the set of A-productions for which A is the leftmost symbol of the right hand side. T. GILs contain languages which are proven not to be in the LIL set. I. I ∪ {γ }.116 CHAPTER 6. S) be a LIG. P.. T. 6. However we show in the next section that such a claim does not seem to hold. P. S) be a LIG. The proof of this lemma holds for the GIG case because there is no stack information aﬀected. Let A[. index γ to I and replacing the A−productions by the productions: A[. I. Therefore.3 in [41]. A similar lemma for CFGs is lemma 4. as long as the left recursion involves the whole spine.. This is easy to prove.] → B[]α be a production in P and B[. Let G1 = (N.. Lemma 11 Let G = (N. just a change in the interpretation of the derivation.. I. if a lemma such as the following statement could be proved. P. P 1.γ i ] → β 1 |β 2 | · · · |β s be the remaining A−productions.1 LIGs in push-Greibach Normal Form We can apply the techniques for left recursion elimination used in the conversion to Greibach Normal Form in CFGs.] such that 1 ≤ i ≤ r .γ 2 ]α2 | · · · |A[.] such that 1 ≤ i ≤ s B[..γ i ] → β i ..2.. from a LIG derivation to a GIG derivation and the equivalence is easy obtained..γ i ] → αi . The following lemma applies to productions that do not carry stack information.] → [.. S) be the LIG formed by adding the variable B to N .

There is no way that a LIG like the one generating the three dependencies could be transformed into a LIG in push-GNF.b.] a b c d a b c d [b..b.a] [d.] [a] a b c d [c.a] [b.b.b.d] b [d] c d Figure 6.a] [d.a] [c.a] [a] [.a] [b.] [a] a b c d d c b a [b. . [.c. such as index renaming: [.c.d] a [b.d] [c.a] [d.a] [c.] [.a] [a.d] [c.c. second case The structures depicted in ﬁgure 6.14 would require even more additional machinery.b.6.a] [a] a b c d d c b a Figure 6.d] [d] [.b.a] [c.2.c.12: Left and right recursive equivalence in LIGs The previous lemma would not work in the following structure.a] [c. without some mayor changes in the mapping algorithm.a] [c...b..12 involving the palindrome language would be obtained.a] [b.b. the equivalence of the structures in ﬁgure 6..13: Left and right recursive equivalence in LIGs..c.a] [a] [.] [a] [b.b.] [.b.. because it would need some additional changes.c.] [b. SET INCLUSION BETWEEN GIGS AND LIGS 117 In this way.

this alternative .] c c d d b Figure 6...] c c d CHAPTER 6.e.] [i] b [i.i] [i] [.118 [. They are however generated by GIGs as shown in ﬁgure 6. both right and left) for push productions.15: LIGs not in push-GNF II These languages do not seem to be obtainable with a LIG in push-GNF..i] d [i] b b [..] [i] [i.16 It seems that some of the above-mentioned issues would still arise if we try to obtain the inclusion of LILs by simulating either an EPDA or Becker’s 2-SA with a LR-2PDA. The problem is that they require the two directions of recursion (i. However.14: LIGs not in push-GNF I Moreover some additional problems arise as in the following languages: {w1 w2 w1 w2 R |wi ∈ Σ∗ } {w1 w2 w2 w1 R |wi ∈ Σ∗ } which can be depicted by the following structures: push push push b1 b2 a1 push push push a2 b3 push a3 push push a1 a2 b1 b2 push push pop pop pop pop push a3 a3 a2 a1 pop b3 pop b3 b2 b1 pop pop pop b3 b 2 a3 a2 pop pop b1 a1 Figure 6. APPLICABILITY OF GIGS [.

There has been some work compiling HPSGs into TAGs (cf. [39]) to allow to push/pop several symbols from the stack. In this section.16: LIGs not in push-GNF II in GIGs should be considered in detail. Therefore. 6. Such compilation process allowed the identiﬁcation of signiﬁcant parts of HPSG grammars that were mildly context-sensitive. This does not change the power of the formalism.3. This follows from the ability of GIGs to capture dependencies through diﬀerent paths in the derivation. We will introduce informally some slight modiﬁcations to the operations on the stacks performed ¯ by a GIG. We will allow the productions of a GIG to be annotated with ﬁnite strings in I ∪ I instead of single symbols. [8]). by performing HPSG derivations at compile time.3 GIGs and HPSGs We showed in the last section how GIGs can produce structural descriptions similar to those of LIGs. [48].6. we will show how the structural descriptive power of GIGs is not only able to capture those phenomena but also additional structural descriptions compatible with those generated by HPSGs [61] schemata. Also the symbols will be interpreted relative to the elements in the top of the stack (as a Dyck set). Those structural descriptions corresponding to ﬁgure 6. GIGS AND HPSGS 119 pop pop push b pop push 1 a1 a2 b2 push pop pop a3 pop b3 a3 a2 a1 push b 3 push b 2 push b1 Figure 6. One of the motivations was the potential to improve the processing eﬃciency of HPSG. diﬀerent derivations .2 were correlated to the use of the SLASH feature in GPSGs and HPSGs. It is a standard change in PDAs (cf. and others which are beyond the descriptive power of LIGs and TAGs.

obtaining very similar structural descriptions. APPLICABILITY OF GIGS might be produced using the same production. 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. Head-Subj-Schema Figure 6.17: Head-Subject Schema 2 2 33 HEAD 1 6 77 6 6 6 77 6 6 77 6 S 6 L | C 6SUBJ 6 77 6 6 4 55 6 4 6 3 6 COMPS 6 2 6 2 6 6 6 6 6 6 6 6 6 6 HEAD DTR 6 S | L | 6 6 6 6 6 6 4 6D 6 6 6 6 6 6 6 4 4 COMP-DTR S 2 2 3 7 7 7 7 7 7 7 7 2 3337 7 HEAD 1 77 7 6 7777 6 77 6 7777 6SUBJ 2 7777 6 7777 4 5577 77 COMPS 3 77 77 55 (1) Figure 6. HEAD 1 SUBJ < > H SUBJ 2 1 HEAD SUBJ < 2 > Figure 6.17 depicts the tree structure corresponding to the Head-Subject Schema in HPSG [61]. according to what is on the top of the stack. Example 27 (intransitive verb) XP → Y P XP XP → X YP →Y X→x nv ¯ Y →y n . This is exempliﬁed with the productions X → x and X → x. an how the elements contained in the stack can be correlated to constituents or lexical items (terminal symbols) in a constituent recognition process. The arrows indicate how the transmission of features is encoded in the leftmost derivation order. in particular in the ﬁrst three cases where nv ¯ [n]v diﬀerent actions are taken (the actions are explained in the parenthesis) : nnδ#wXβ ⇒ vnδ#wxβ (pop n and push v) nv ¯ n¯δ#wXβ ⇒ δ#wxβ v nv ¯ (pop n and v ) vnδ#wXβ ⇒ v¯ vnδ#wxβ (push n and v) nδ#wXβ ⇒ ¯ n ¯ nv ¯ [n]v vnδ#wxβ ( check and push) We exemplify how GIGs can generate similar structural descriptions as HPSGs do in a very oversimpliﬁed and abstract way.120 CHAPTER 6.18 shows an equivalent structural description corresponding to the GIG productions and derivation shown in the next example (which might correspond to an intransitive verb).

XP → X CP The derivation: CP → Y CP X → x nv n ¯ ¯ CP → Y →y n n#XP ⇒ n#XCP ⇒ nv#xCP ⇒ nv#xY CP ⇒ v#xyCP ⇒ v#xy ¯ ¯ The productions of example 29 (which uses some of the productions corresponding to the previous schemas) generate the structural description represented in ﬁgure 6.21..20. GIGS AND HPSGS [..] XP [v. 3 57 5 4 COMP-DTR S 4 2 2 33 3 2 > C n-2 3 n H C HEAD 1 COMP < 2 1 . corresponding to the deriva- . The following GIG productions generate the structural description corresponding to ﬁgure 6..3.19: Head-Comps Schema tree representation Figure 6.19 shows the tree structure corresponding to the Head-Complement schema in HPSG.] Y [n.] 121 YP [n.] X x Figure 6...6.] y [v.18: Head-Subject in GIG format #XP ⇒ #Y P XP ⇒ #yXP ⇒ n#Y XP ⇒ n#yX ⇒ v#yx Head-Comps-Schema HEAD COMP 1 < 2 HEAD 1 6 77 7 6 6 7 6 S 4 L | C 4SUBJ 2 55 7 6 7 6 COMPS 3 6 2 2 2 3337 7 6 HEAD 1 7 6 6 6 6 6 7777 6 6 HEAD DTR 4 S | L | 4SUBJ 2 5577 6D 6 77 6 4 COMPS union 4 . where the initial conﬁguration of the stack is assumed to be [n]: Example 28 (transitive verb) . 3 n > Figure 6.] XP [v..

APPLICABILITY OF GIGS XP [ v ] X [n v] [n v] CP [ v ] Y [v] CP x y ε Figure 6. XP → Y P XP CP → Y P CP X → know nv ¯¯ n XP → X CP X → hates nv n ¯ ¯ nv¯ ¯ v XP → X XP CP → X → claims Y P → Kim|Sandy|Dana|we A derivation of ‘Kim we know Sandy claims Dana hates’: #XP ⇒ #Y P XP ⇒ n#Kim XP ⇒ n#Kim Y P XP ⇒ nn#Kim we XP ⇒ nn#Kim we X XP ⇒ v n#Kim we know XP ⇒ ¯ v n#Kim we know Y P XP ⇒ ¯ n¯n#Kim we know Sandy XP ⇒ v n¯n#Kim we know Sandy X XP ⇒ v v n#Kim we know Sandy claims XP ⇒ ¯ v n#Kim we know Sandy claims Y P XP ⇒ ¯ n¯n#Kim we know Sandy claims Dana XP ⇒ v #Kim we know Sandy claims Dana hates Finally the last example and ﬁgure 6. ∗ . We show the contents of the stack when each lexical item is introduced in the derivation.20: Head-Comp in GIG format tion given in example 29.22 shows how coordination combined with SLASH can be encoded by a GIG. Example 29 (SLASH in GIG format) .122 [n] CHAPTER 6.

21: SLASH in GIG format Example 30 (SLASH and Coordination2) . XP → Y P XP CP → Y P CP X → talk to nv n ¯ ¯ XP → X CP CP → C → and X → did nv ¯¯ XP → X XP X → visit [n¯n]c v CXP → XP CXP Y P → W ho|you n CXP → C XP A derivation of ‘Who did you visit and talk to’: #XP ⇒ #Y P XP ⇒ n#W ho XP ⇒ n#W ho Y P XP ⇒ v n#W ho did XP ⇒ ¯ v n#W ho did Y P XP ⇒ n¯n#W ho did you CXP ⇒ ¯ v n¯n#W ho did you XP CXP ⇒ v cn¯n#W ho did you visit CXP ⇒ v cn¯n#W ho did you visit C XP ⇒ v n¯n#W ho did you visit and XP ⇒ v ∗ . GIGS AND HPSGS [] 123 XP YP [n] [n] Kim YP [nn] we XP XP X [vn] know YP [nvn] Sandy XP XP X XP [vn] claims YP [nvn] Dana [] hates XP X CP ε Figure 6.3.6.

22: SLASH and coordination in GIG format .124 #W ho did you visit and talk to XP CHAPTER 6. APPLICABILITY OF GIGS [] YP [n] Who X [nv] did XP XP YP [nvn] you XP [cnvn] visit ε CXP CXP C [ n v n ] XP [] [ n v n] and talk to CP ε Figure 6.

The strong similarity between GIGs and LIGs suggests that LILs might be included in GILs. Finally. it might be diﬃcult to prove it. An Earley type algorithm for the recognition problem of GILs was presented with a bounded polynomial time result O(n6 ) and O(n4 ) space. time-complexity and space complexity properties. we have shown also that the extra power that characterizes GIGs. However we did not discuss the (possible) equivalence of sLR-2PDAs and trGIGs. We showed u the descriptive power of GIGs regarding the three phenomena concerning natural language context sensitivity: reduplication. We introduced trGIGs (and sLR-2PDAs) which are more restricted than GIGs. We conjectured that trGIGs are not able to capture reduplication phenomena. We showed the equivalence of LR-2PDA and GIGs. or it might not be the case and both languages turn out to be incomparable. corresponds to the ability of GIGs to 125 . We also showed that both the weak and the strong descriptive power of GIGs is beyond LIGs. However. multiple agreements and crossed agreements. GIGs. A proof of semilinearity showed that GILs share mildly context sensitive properties. We have shown that GIGs generate structural descriptions for the copy and multiple dependency languages which can not be generated by LIGs. The proof of correctness of this algorithm was also presented using the Parsing Schemata framework.Chapter 7 Conclusions and Future Work We have presented LR-2PDAS. and that are more limited regarding crossed agreements. GILs and their properties. We analyzed the algorithm providing an account of grammar-size. We presented a Chomsky-Sch¨tzenberger representation theorem for GILs. We presented a comparison of the structural descriptions that LIGs and GIGs can be generate.

which follows as a corollary from the semi-linearity property. except the emptiness problem. CONCLUSIONS AND FUTURE WORK generate dependent paths without copying the stack but distributing the control in diﬀerent paths through the leftmost derivation order. However. We also mentioned the issue of ambiguity and we deﬁned GILs with deterministic indexing. We have not addressed most of the decision problems. GILs and GCSLs are incomparable but trGILs might be a properly included in GCSLs. We mention now some of the issues that might be addressed in future research. and we gave an algorithm to parse LR(k) GILs. the proof should be considered in detail. 7. We have shown also that those non-local relationships which are usually encoded in HPSGs as feature transmission can be encoded in GIGs using its stack.126 CHAPTER 7. however it is not clear to us if such a pumping lemma would provide an additional tool beyond the result already obtained on semilinearity. A candidate pumping lemma for GILs was suggested. and the membership problem. we did not explore the properties of the class of deterministic GILs. They seem to be a proper subset of GILs and they also seem to be closed under complementation (which could be proved following the proof for CFLs). The relationships between GILs LILs and ILs is still an open question. In this case. coupled context-free grammars among other formalisms. this class might not have any theoretical import besides the fact that the recognition problem is in O(n3 ). The similarity of GIGs and counter automata. We gave an Earley algorithm for GIGs . We deﬁned deterministic LR-2PDAs and deterministic GILs. should be addressed. Although they do seem to be. exploiting the ability of GIGs to encode dependencies through connected dependent paths and not only through a spine. however there are other variations on Earley’s algorithm that were not considered and that might improve the impact of the grammar size on the parsing . We have established some coarse-grain relations with other families of languages (CFLs and CSLs).1 Future Work The results described in the previous section are encouraging enough to continue further work concerning Global Index Languages. however. it is harder to determine whether GILs with deterministic indexing are a proper subset of the Global Index Languages.

7.1. FUTURE WORK

127

complexity. There are also some details on the introduction of indices which would improve its performance. Another alternative to be considered is extension of the LR(k) algorithm to generalized LR(k) ` la Tomita. If a Chomsky Normal Form for GILs is obtainable, a CYK bottom-up algorithm a could be considered. We considered some of the issues related to Natural Language from a formal and abstract point of view, i.e. language sets and structural descriptions. In the same perspective it might be interesting to see if GILs are able to describe some phenomena that are beyond mildly-context sensitive power (e.g. scrambling). Also, we only compared GILs with LIGs; there are other formalisms to be considered. Minimalist Grammars [78] share some common properties with GILs. It would be interesting to determine if minimalist grammars can be compiled into GILs. In the area of practical applications, it would be interesting to implement the HPSG compilation ideas. Another relevant question is how much of TAG systems can be compiled into GIGs and how do the performances compare. It should be noted that the capabilities of TAGs to deﬁne extended domains of locality might be lost in the compilation process. We mentioned in the introduction some of the approaches to use generative grammars as models of biological phenomena. The capabilities of GIGs to generate the multiple copies language (or multiple repeats in the biology terminology) as well as crossing dependencies (or pseudo-knots) might be used in the computational analysis of sequence data.

128

CHAPTER 7. CONCLUSIONS AND FUTURE WORK

Bibliography

[1] A. V. Aho. Indexed grammars - an extension of context-free grammars. Journal of the Association for Computing Machinery, 15(4):647–671, 1968. [2] A. V. Aho, R. Sethi, and J. D. Ullman. Compilers: Principles, Techniques, and Tools. AddisonWesley, Reading, MA, 1986. [3] M. A. Alonso, D. Cabrero, and M. Vilares. Construction of eﬃcient generalized LR parsers. In Derick Wood and Sheng Yu, editors, Automata Implementation, volume 1436, pages 7–24. Springer-Verlag, Berlin-Heidelberg-New York, 1998. [4] M. A. Alonso, E. de la Clergerie, J. Gra˜a, and M. Vilares. New tabular algorithms for LIG n parsing. In Proc. of the Sixth Int. Workshop on Parsing Technologies (IWPT’2000), pages 29–40, Trento, Italy, 2000. [5] J. Autebert, J. Berstel, and L. Boasson. Context-free languages and pushdown automata. In A. Salomaa and G. Rozenberg, editors, Handbook of Formal Languages, volume 1, Word Language Grammar, pages 111–174. Springer-Verlag, Berlin, 1997. [6] G. Barton, R. Berwick, and E. Ristad. Computational Complexity and Natural Language. MIT Press, Cambridge, 1987. [7] T. Becker. HyTAG: a new type of Tree Adjoining Grammars for Hybrid Syntactic Representation of Free Order Languages. PhD thesis, University of Saarbruecken, 1993. [8] T. Becker and P. Lopez. Adapting HPSG-to-TAG compilation to wide-coverage grammars. In Proceedings of TAG+5, pages 47–54. 2000.

129

The variable membership problem: Succinctness versus complexity. 1994. Niemann. editors. [14] G. In In Proceeding of CIAA 2003. pages 15–22. 1982. 29:171–182. 2003. Range concatenation grammars. Italy. 1995. Chinese numbers. pages 595–606. Mach.. In Proceedings of the 12th Symposium on Theoretical Aspects of Computer Science. n In Proc. Mexico City. Buntrock and G. [12] P. In Automata. of Cicling 2003.CA. [15] G. J. Otto. Lecture Notes in Computer Science. In Proceedings of the Sixth International Workshop on Parsing Technologies (IWPT2000). GIGs: Restricted context-sensitive descriptive power in bounded polynomial-time. Weakly growing context-sensitive grammars. mix. n Santa Barbara. Lorys. In Symposium on Theoretical Aspects of Computer Science. Conﬂuent and other types of thue systems. pages 53–64. and range concatenation grammars. Buntrock and K. Philadelphia. 1998. 14 pages. Boullier.. Lorys. LR Parsing for Global Index Languages (GILs). [19] J. Buntrock and F. In TAG Workshop. Boullier. February 16-22. pages 77–88. Casta˜o. Casta˜o. [16] G. Boullier. On growing context-sensitive languages. [11] P. . 1996. Proceedings of the ACL-2003 Student ¨ Research Workshop. [13] G. Book. [17] J. Research Report RR-3614. In Sandra K n ubler Kotaro Funakoshi and Jahna Otterbacher.130 BIBLIOGRAPHY [9] R. Languages and Programming. Assoc. volume 900. scrambling. Chicago Journal of Theoretical Computer Science. A generalization of mildly context-sensitive formalisms. 2003. Casta˜o. January 1999. [10] P. Rocquencourt. Growing context sensitive languages and church-rosser languages. 2003. 1992. France. Trento. February 2000. Comput. [18] J. On the applicability of global index grammars. INRIA. Buntrock and K.

The Mathematical Theory of Context Free Languages. K. The Netherlands. C. Reghizzi. Gazdar. 1996. Bloomington. Salomaa. Handbook of Formal Languages. Communications of the ACM. In R. Amsterdam. Dahlhaus and M. and A. On parsing coupled-context-free languages. editors. 1986. Springer. P˘un.. Oehrle and J. 1963. MOL 8. International Journal of Foundations of Computer Science. Casta˜o. Sci. Comp. Computer Programming and Formal Systems. Reyle and C. 1996. Chomsky and M. North-Holland. [29] G. Indiana.-P. Citrini. Linguistics and Philosophy. Berlin. Global index grammars and descriptive power. Berlin. 7(3):253–292. and S. pages 85–99. Rogers. Warmuth. In G. Membership for growing context sensitive grammars is polynomial. Salomaa. 8:345–351. pages 118–161. Hirschberg. The complexity of the vocabulary of bambara. editors. Reidel. [27] J. n Proc. 13:94– 102. In U. 2003b.BIBLIOGRAPHY 131 [20] J. Hotz. [24] E. Rohrer. [23] C. [26] J. P˘un. Applicability of indexed grammars to natural languages. Cherubini. Braﬀort and D. Ginsburg. pages 205– 233. Multipushdown languages and grammars. 1997. . Springer. [30] S. In Colloquium on Trees in Algebra and Programming. pages 69–94. [22] N. New York. Rozenberg a and A. 1989. 2. [21] A. editors. Natural Language Parsing and Linguistic Theories. Grammars with controlled derivations. New York. [25] J. Regulated Rewriting in Formal Language Theory. An Eﬃcient Context-free Parsing Algorithm. a Heidelberg. Breveglieri. Pitsch G. 1966. Dassow. 1988. Sch¨tzenberger. Dordrecht. L. 1970. Culy. [28] G. The algebraic theory of context-free languages. Dassow and G. of Mathematics of Language. 1985. June. In u P. Earley. Mc Graw Hill. G. Theor. editors. Vol. D.

No. Centrum voor Wiskunde en Informatica (CWI).. 1987. [42] O. AFL with the semilinear property. New York. Spanier. . languages: where computer science. Words. Decision questions concerning semilinearity. University College. Parsing contextual grammars with linear. Tokio. Massachusetts. [36] K. Languages. 2000. Journal of the Association for Computing Machinery. Addison-Wesley Publishing Company. Harkema. Mitrana. 3:428–446. Formal language theory and dna: An analysis of the generative capacity of speciﬁc recombinant behaviors. Springer. Reversal-bounded multicounter machines and their decision problems. Ginsburg and E. A recognizer for minimalist grammars. H. H. Dublin. [37] T. In IWPT 2000. Hopcroft and Jeﬀrey D. Ginsburg and E. 1995. Mild context-sensitivity and tuple-based generalizations of context-free grammar. regular and context-free selectors. [35] A. ISSN 0169-118X. and A. 1971. 1979. Literal movement grammars. [38] H. Harbush. Inc. [34] A. [39] M. 2000. 1978. [40] T. 5(4):365–396. In Martin-Vide and V. H. Berling. 1966. biology and linguistics meet. One-way nondeterministic real-time list-storage. Finite-turn pushdown automata. Addison-Wesley. In LNCS 2076. [41] J. 4(3):429–453. MA. Harju. E. 1968. Ibarra. Harrison. Journal of the ACM (JACM). H.132 BIBLIOGRAPHY [31] S. Karhum¨ki. sequences. and Computation. O. Salomaa. Spanier. Head. editors. Ibarra. Harrison. Groenink. page 579ﬀ. Introduction to Automata Theory. Journal of Computer and System Sciences. Bulletin of Mathematical Biology. 1995. Reading. a morphisms and commutation of languages. 1978. Springer. [33] S. 25(1):116–133. pages 737–759. page 22. Introduction to Formal Language Theory. In Proceedings of the 7th EACL Conference. Ullman. 15. 30 1996. J. Reading. [32] S. SIAM Journal on Control. 2001. Ginsburg and M. Groenink. In 104.

BIBLIOGRAPHY 133 [43] A. Manning. Local tree description grammars: A local extension of tag allowing underspeciﬁed dominance relations. volume 14 of Lecture Notes in Computer Science. editors. [47] Laura Kallmeyer. pages 92–99. Languages and Programming. 8(2):142–157. 1974. In Automata. u [52] Carlos Mart´ ın-Vide and et al. [48] R. pages 206– 250. Vijay-Shanker. Berlin. [45] A. In G. pages 107–114. In Proceedings of the 7th International Workshop on Parsing Technologies. Cambridge. 2000. [46] A. Weir. Sewing contexts and mildly context-sensitive languages. pages 85–137. [51] B. Parsing and hypergraphs. In Proceedings of the Fifth International Workshop on Tree Adjoining Grammars and Related Formalisms (TAG+5). Springer. Joshi. . and Thomas Wasow. 1974. A geometric hierarchy of languages. Deterministic techniques for eﬃcient non-deterministic parsers. Stuart Shieber. In Peter Sells. 2001. [49] N. Salomaa. Foundational issues in natural language processing. MIT Press. Vol. [50] Dan Klein and Christopher D. editors. and A. Joshi. A. 3. and D. Kiefer. Compilation of HPSG into TAG. 2001. Lang. computational and theoretical perspectives. 1991. Mass. K. Saarbr¨cken. L. Journal of Computer and System Sciences.. pages 255–269. Joshi. Paris. pages 31–81. Kasper. Dowty. and K. 257. Chicago University Press. Rozenberg and A. 1997. [44] A. K. In Proceedings of the 33rd Annual Meeting of the Association for Computational Linguistics. March 1999. Handbook of Formal Languages. The convergence of mildly context-sensitive grammatical formalisms. TUCS Technical Report No. MA. France. Schabes. Netter. New York. B. Khabbaz. editors. Karttunen. 1985. Cambridge. Joshi and Y. Tree-adjoining grammars. Vijay-Shanker. Tree adjoining grammars: How much context-sensitivity is required to provide reasonable structural description? In D. Zwicky. Grammars. 2nd Colloquium. Relationship between strong and weak generative power of formal systems. 1995. Natural language processing: psycholinguistic.

Kracht. pages 243–257. [62] S. Rajasekaran. [55] J. The church-rosser languages are the deterministic variants of the growing context-sensitive languages. 1999. Pollard and I. Tree-adjoining language parsing in o(n6 ) time. Journal of the Association for Computing Machinery. pages 329–345. 13:570–581. A. PhD thesis. 1998. Springer-Verlag. LNCS 1631. In Proceedings of Logical Aspects of Computational Linguistics. Italy. In Foundations of Software Science and Computation Structure. Sag. Formal and Computational Aspects of Natural Language Syntax. 1994. e LACL’96: First International Conference on Logical Aspects of Computational Linguistics. Alonso Pardo. Rambow. 1998. Stanford University. PhD thesis. University of Chicago Press. 1997. USA. LACL’98. Niemann and F. Otto. 1996. [58] F. RTA-99. Miller. [59] M. Michaelis and M. BIBLIOGRAPHY In Jewels are Forever. Philadelphia. Head-driven Phrase Structure Grammar. IL. 1999. 25. SIAM J. On context-free languages. 1999. [57] G. Chicago. Parikh. Interpretaci´n Tabular de Aut´matas para lenguajes de Adjunci´n de o o o ´ Arboles. In Rewriting Techniques and Applications: 10th International Conference. Grenoble. [63] O. n [60] Rohit J. Springer-Verlag. Berlin. In Christian Retor´. Dept of CIS. CSLI Publications. McNaughton. pages [54] J. [56] P. Semilinearity as a syntactic invariant.A. 1966. Universidade da Coru˜a. 1994. editor. Michaelis. [61] C. Strong Generative Capacity.134 [53] R. of Computation. . University of Pennsylvania. On the connections between rewriting and formal language theory. Derivational minimalism is mildly context-sensitive. 2000. Stanford CA. An insertion into the chomsky hierarchy? 204–212. Otto. Trento.

1998. Principles and implementation of deductive parsing. [71] H. T. 20. Parsing schemata. Linguistics and Philosophy. C. [67] G. 1985.R. 8:333–343. 199(1–2):87–103. A dynamic programming algorithm for rna structure prediction including pseudoknots. Shieber and Y. DIMACS Series in Discrete Mathematics and Theoretical Computer Science. [72] S. Fujii.R. Artiﬁcial Intelligence and Molecular Biology. Hunter. 1995. 1997.BIBLIOGRAPHY 135 [64] E. pages 334–340. Bioinformatics. Science. Shieber. and T. In L. Y. Schabes. On multiple context-free grammars. Mol Biol. Journal of Logic Programming. Seki. Shieber. 24:3–36. [65] E. 1999. Computational linguistics. The computational linguistics of biological sequences. Sikkel. J. pages 245–274. Searls. Journal of Logic Programming. An alternative conception of tree-adjoining derivation. M. and F. page 117ﬀ. 24(1 and 2):73–102. Schabes. editor. 1995. AAAI Press. Theoretical Computer Science. Kasami. pages 47–120. Parsing schemata and correctness of parsing algorithms. . Satta. [75] K. [68] D. 1994.B. 1998. [69] D. No. 20:91–124. Evidence against the context-freeness of natural language. Matsumura. B. String variable grammar: A logic grammar formalism for the biological language of DNA. Eddy. [76] K. Rivas and S. pages 2053–2068. [74] S. Paun S. 2. Martin-Vide. Eddy. pages 191–229. Springer-Verlag. Computational Linguistics.M. Searls. Marcus. [73] S. Computational Linguistics. 2000. Contextual grammars as generative models of natural languages. 1991. Tree-adjoining grammar parsing and boolean matrix multiplication.B. Searls. The language of rna: A formal grammar that includes pseudoknots. Rivas and S. Pereira. Theoretical Computer. Formal language theory and biological macromolecules. Sikkel.M. 1994. [66] Gh. 1999. [70] D. 1993.

V. University of Pennsylvania. A tabular interpretation of a class of 2-stack automata. Wartena. Grammars. Massachusetts. 1328. 1987. Information and Control. Stabler. P. Vijay-Shanker. A. 1985. Characterizing mildly context-sensitive grammar formalisms. [83] D. CA. Introduction to the Theory of Computation. pages 11–14. [87] D. Tomita. de la Clergerie and M. pages 1333–1339. 13:31–46. Sipser. and A. Language. [78] E. D. [79] M. A. Theoretical Computer Science. Boston. J. [80] M. Dependency and coordination in the grammar of dutch and english. Pardo. Joshi. PhD thesis. 1997. In COLING-ACL. On the concatenation of one-turn pushdowns. 104(2):235–261. J. Wartena. Grenoble. 1992. 1970.136 BIBLIOGRAPHY [77] M. 1998. 32 No. Steedman. . pages 259–269. 1997. Stanford. K. 1999. [82] K. A. In Proceedings of the Conference on Logical Aspects of Computational Linguistics (LACL ’98). Characterizing structural descriptions produced by various grammatical formalisms. Workman. pages 523–568. 17:41–61. An eﬃciente augmented-context-free parsing algorithm. Grammars with composite storages. 1988. PWS Publishing Company. Walters. 2:188–200. A geometric hierarchy beyond context-free languages. 1998. [86] D. Computational linguistics. Turn-bounded grammars and their relation to ultralinear languages. [81] E. Weir. Lecture notes in computer science. Derivational minimalism. Deterministic context-sensitive languages: Part II. Weir. In Proc. pages 104–111. Information and Control. [84] C. Weir. of the 25th ACL. 1987. [88] D. [85] Ch. 1976.

Sign up to vote on this title

UsefulNot useful- Lab Prgrms30
- Algorithms by Codewell
- npdadoc
- 141353-LM
- english
- TESOL-Program.pdf
- They Are Rapid Methods for the Investigation of the Language
- 9A05407 Formal Languages and Automata Theory
- H6-sol
- Teaching Children
- Capitolul II Corectat Final
- Hybrid Systems Modeling
- Writing Rubric
- dikarezkyana
- Chapter 1
- Help Sts Enjoy Grammar
- MELJUN CORTES CS113_StudyGuide_chap7
- CS301_2nd_Assignment Idea Solution Fall 2011
- Data Structures & System Programming Lab File
- Reviewing the Puzzle of CLIL
- Reviewing the Puzzle of CLIL, Ioannou Georgiou READ
- Current Issues in Linguistic Theory 5th Printing Janua Linguarum Series Minor 38
- Getting People to Say Yes
- ESP
- teaching grammar.docx
- BI Teacher Guidebook Year 2
- english
- English_Teacher_Guidebook_Year_2.pdf
- Teacher's Guide Year 3 SK & SJK
- PANDUAN GURU
- 10.1.1.121.8248

Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

We've moved you to where you read on your other device.

Get the full title to continue

Get the full title to continue reading from where you left off, or restart the preview.