Base_JSON/prefixJ/json/J93/J93-4002.json

{
    "paper_id": "J93-4002",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T02:59:32.319485Z"
    },
    "title": "Parsing Some Constrained Grammar Formalisms",
    "authors": [
        {
            "first": "K",
            "middle": [],
            "last": "Vijay-Shanker",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Delaware",
                "location": {
                    "postCode": "19716",
                    "settlement": "Newark",
                    "region": "DE"
                }
            },
            "email": ""
        },
        {
            "first": "David",
            "middle": [
                "J"
            ],
            "last": "Weir",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Delaware",
                "location": {
                    "postCode": "19716",
                    "settlement": "Newark",
                    "region": "DE"
                }
            },
            "email": "davidw@cogs.susx@ac.uk."
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "In this paper we present a scheme to extend a recognition algorithm for Context-Free Grammars (CFG) that can be used to derive polynomial-time recognition algorithms for a set of formalisms that generate a superset of languages generated by CFG. We describe the scheme by developing a Cocke-Kasami-Younger (CKY)-like pure bottom-up recognition algorithm for Linear Indexed Grammars and show how it can be adapted to give algorithms for Tree Adjoining Grammars and Combinatory Categorial Grammars. This is the only polynomial-time recognition algorithm for Combinatory Categorial Grammars that we are aware of. The main contribution of this paper is the general scheme we propose for parsing a variety of formalisms whose derivation process is controlled by an explicit or implicit stack. The ideas presented here can be suitably modified for other parsing styles or used in the generalized framework set out by Lang (1990).",
    "pdf_parse": {
        "paper_id": "J93-4002",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "In this paper we present a scheme to extend a recognition algorithm for Context-Free Grammars (CFG) that can be used to derive polynomial-time recognition algorithms for a set of formalisms that generate a superset of languages generated by CFG. We describe the scheme by developing a Cocke-Kasami-Younger (CKY)-like pure bottom-up recognition algorithm for Linear Indexed Grammars and show how it can be adapted to give algorithms for Tree Adjoining Grammars and Combinatory Categorial Grammars. This is the only polynomial-time recognition algorithm for Combinatory Categorial Grammars that we are aware of. The main contribution of this paper is the general scheme we propose for parsing a variety of formalisms whose derivation process is controlled by an explicit or implicit stack. The ideas presented here can be suitably modified for other parsing styles or used in the generalized framework set out by Lang (1990).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "This paper presents a scheme to extend known recognition algorithms for Context-Free Grammars (CFG) in order to obtain recognition algorithms for a class of grammatical formalisms that generate a strict superset of the set of languages generated by CFG. In particular, we use this scheme to give recognition algorithms for Linear Indexed Grammars (LIG), Tree Adjoining Grammars (TAG), and a version of Combinatory Categorial Grammars (CCG). These formalisms belong to the class of mildly contextsensitive grammar formalisms identified by on the basis of some properties of their generative capacity. The parsing strategy that we propose can be applied to the formalisms listed as well as others that have similar characteristics (as outlined below) in their derivational process. Some of the main ideas underlying our scheme have been influenced by the observations that can be made about the constructions used in the proofs of the equivalence of these formalisms and Head Grammars (HG) (Vijay-Shanker 1987; Weir 1988 ; Vijay-Shanker and Weir 1993) .",
                "cite_spans": [
                    {
                        "start": 988,
                        "end": 1008,
                        "text": "(Vijay-Shanker 1987;",
                        "ref_id": "BIBREF13"
                    },
                    {
                        "start": 1009,
                        "end": 1018,
                        "text": "Weir 1988",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 1039,
                        "end": 1049,
                        "text": "Weir 1993)",
                        "ref_id": "BIBREF17"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "There are similarities between the TAG and HG derivation processes and that of Context-Free Grammars (CFG). This is reflected in common features of the parsing algorithms for HG (Pollard 1984) and TAG (Vijay-Shanker and Joshi 1985) and the CKY algorithm for CFG (Kasami 1965; Younger 1967) . In particular, what can happen at each step in a derivation can depend only on which of a finite set of \"states\" the derivation is in (for CFG these states can be considered to be the nonterminal symbols). This property, which we refer to as the context-freeness property, is important because it allows one to keep only a limited amount of context during the recognition process, which results in polynomial time algorithms. In the recognition algorithms mentioned above for CFG, HG, and TAG this is reflected in the fact that the recognizer can encode intermediate stages of the derivation with a bounded number of states. An array is used whose entries are associated with a given component of the input. In the case of the CKY algorithm, the presence of a particular nonterminal in an array entry is used to encode the fact that the nonterminal derives the associated substring of the input. The context-freeness of CFG has the consequence that there is no need to encode the way, or ways, in which a nonterminal came to be placed in an array entry.",
                "cite_spans": [
                    {
                        "start": 178,
                        "end": 192,
                        "text": "(Pollard 1984)",
                        "ref_id": "BIBREF9"
                    },
                    {
                        "start": 201,
                        "end": 231,
                        "text": "(Vijay-Shanker and Joshi 1985)",
                        "ref_id": "BIBREF14"
                    },
                    {
                        "start": 262,
                        "end": 275,
                        "text": "(Kasami 1965;",
                        "ref_id": "BIBREF6"
                    },
                    {
                        "start": 276,
                        "end": 289,
                        "text": "Younger 1967)",
                        "ref_id": "BIBREF20"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "In this respect, the derivation processes of CCG and LIG would appear to differ from that of CFG. In these systems unbounded stacklike structures replace the role played by nonterminals in controlling derivation choices. This would seem to suggest that the context-freeness property of CFG, HG, and TAG derivations no longer holds. Unbounded stacks can encode an unbounded number of earlier derivation choices. In fact, while the path sets 1 of CFG, HG, and TAG derivation trees are regular languages, the path sets of CCG and LIG are context-free languages. With respect to recognition algorithms, this suggests that the array (whose entries contain nonterminals in the case of CFG) would need to contain complete encodings of unbounded stacks giving an exponential time algorithm. However, in LIG and CCG, the use of stacks to control derivations is limited in that different branches of a derivation cannot share stacks. Thus, despite the above observations, the context-freeness property does in fact hold. A detailed explanation of why this is so will be presented below. We propose a method to extend the CKY algorithm to handle the limited use of stacks found in CCG and LIG. We have chosen to adapt the CKY algorithm since it is the simplest form of bottom-up parsing. A similar approach using Earley algorithm is also possible, although not considered here. Since the use of the stacks is most explicit in the LIG formalism we describe our approach in detail by developing a recognition algorithm for LIG (Sections 2 and 3). We then show how the general approach suggested in the parser for LIG can be tailored to CCG (in Section 4). In the above discussion TAG has been grouped with HG. However, TAG can also be viewed as making use of stacks in the same way as LIG and CCG. In Section 5 we show how the LIG algorithm presented in Section 3 can be adapted for TAG.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1."
            },
            {
                "text": "An Indexed Grammar (Aho 1968 ) can be viewed as a CFG in which objects are nonterminals with an associated stack of symbols. In addition to rewriting nonterminals, the rules of the grammar can have the effect of pushing or popping symbols on top of the stacks that are associated with each nonterminal. Gazdar (1988) discussed a restricted form of Indexed Grammars in which the stack associated with the nonterminal on the left of each production can only be associated with one of the occurrences of nonterminals on the right of the production. Stacks of bounded size are associated with other occurrences of nonterminals on the right of the production. We call this Linear Indexed Grammars (LIG). 2",
                "cite_spans": [
                    {
                        "start": 19,
                        "end": 28,
                        "text": "(Aho 1968",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 303,
                        "end": 316,
                        "text": "Gazdar (1988)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Indexed Grammars",
                "sec_num": "2."
            },
            {
                "text": "1 The path set of a tree is the set of strings labeling paths from the root to the frontier of the tree. The path set of a tree set is the union of path sets of trees in the set. 2 The name Linear Indexed Grammars is used by Duske and Parchmann (1984) to refer to a different restriction on Indexed Grammars in which production was restricted to have only a single nonterminal on their right-hand side.",
                "cite_spans": [
                    {
                        "start": 225,
                        "end": 251,
                        "text": "Duske and Parchmann (1984)",
                        "ref_id": "BIBREF1"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Indexed Grammars",
                "sec_num": "2."
            },
            {
                "text": "Definition 2.1 A LIG, G, is denoted by (VN, VT, VI, S, P) where VN is a finite set of nonterminals, VT is a finite set of terminals, VI is a finite set of indices (stack symbols), Derivation tree for LIG.",
                "cite_spans": [
                    {
                        "start": 39,
                        "end": 57,
                        "text": "(VN, VT, VI, S, P)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Indexed Grammars",
                "sec_num": "2."
            },
            {
                "text": "sf",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Indexed Grammars",
                "sec_num": "2."
            },
            {
                "text": "In this paper rather than adopting the general form of rules as given above, we restrict our attention to grammars whose rules have the following form. In fact, this can be easily seen to constitute a normal form for LIG. 3. a ('\" '71\". \"Ym) --\" As (OLs) ap (.. ~p) where m > 0. where m > 0.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Linear Indexed Grammars",
                "sec_num": "2."
            },
            {
                "text": "We allow at most two symbols in the right-hand side of productions because we intend to develop CKY-style algorithms. In the above rules we say that AF (.. \"yp) is the primary constituent and As (c~s) is the secondary constituent. Notice also that in a derivation using such a rule, the primary constituent yields the distinguished child. (In grammatical theories that use a stack of subcategorized arguments, the top of the stack in the primary constituent determines which secondary constituent it can combine with.)",
                "cite_spans": [
                    {
                        "start": 152,
                        "end": 160,
                        "text": "(.. \"yp)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "A",
                "sec_num": "4."
            },
            {
                "text": "Let us consider how we may extend the CKY algorithm for the recognition of LIG. Given a fixed grammar G and an input al \u2022 .. an, the recognition algorithm will complete an n x n array P such that an encoding of A (cO is stored in P [i, d] if and only if A (oQ ai... ai+d-1. The algorithm will operate bottom-up. For example, if G contains the rule a ('\" \")11... \"Ym) ---+ ap (.. \"~p) A s (O~s) and we find an encoding of Ap (O<p'yp) in P Ii, dp] and an encoding of As (C~s) in P Ii + dp~ ds] then an encoding of A (C~p'yl... \"Ym) will be stored in P Ii, dp + dsl. What encoding scheme should be used? The most straightforward possibility would be to store a complete encoding of A (c~p3,~... 3,m) in P [i, dp + ds]. However, in general, if an object A (~) derives a string of length d then the length of o~ is (,.9(d) . 3 Hence there can be O(/d) objects that derive a substring of the input (of length d), for some constant k. Hence, the space and time complexity of this algorithm is exponential in the worst case. 4",
                "cite_spans": [
                    {
                        "start": 232,
                        "end": 238,
                        "text": "[i, d]",
                        "ref_id": null
                    },
                    {
                        "start": 424,
                        "end": 432,
                        "text": "(O<p'yp)",
                        "ref_id": null
                    },
                    {
                        "start": 679,
                        "end": 696,
                        "text": "A (c~p3,~... 3,m)",
                        "ref_id": null
                    },
                    {
                        "start": 810,
                        "end": 817,
                        "text": "(,.9(d)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Terminators",
                "sec_num": "2.1"
            },
            {
                "text": "The inefficiency of this approach can be seen by drawing an analogy with the following algorithm for CFG. Suppose rather than storing sets of nonterminals in each array entry, we store a set of trees containing all derivation subtrees that yield the corresponding substring. The problem with this is that the number of derivation trees is exponential with respect to the length of the string spanned. However, there is no need to store derivation trees since in considering the combination of subderivation trees in the CFG, only the nonterminals at the root of the tree are relevant in determining whether there is a production that licenses the combination.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Terminators",
                "sec_num": "2.1"
            },
            {
                "text": "Likewise because of the last-in first-out behavior in the manipulation of stacks in LIG, we will argue that it is not necessary to store the entire stack. For instance, consider the derivation (depicted by the tree shown in Figure 2 ) from the point of view of recording the derivation in a bottom-up parser (such as CKY). Let a node ~?1 labeled B (fl3,1 ... 3,k... 3,m) be a distinguished descendant of a node ~1 labeled A (fl3,1 ... 3,k) as shown in the figure. Viewing the tree bottom-up, let the node ~], labeled A (fl3,1 \u2022 \u2022. 3,k), be the first node above the node ~71, labeled B (fl3,1 \u2022. \u2022 3,k. \u2022 \u2022 3,m) , where 3,k gets exposed as the top of the stack. Because of the last-in first-out behavior, every distinguished descendant of ~] above 711 will have a label of the form A I (fl3,1 ... 3,k~) where len (~) > 1.",
                "cite_spans": [
                    {
                        "start": 422,
                        "end": 439,
                        "text": "A (fl3,1 ... 3,k)",
                        "ref_id": null
                    },
                    {
                        "start": 570,
                        "end": 610,
                        "text": "~71, labeled B (fl3,1 \u2022. \u2022 3,k. \u2022 \u2022 3,m)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 224,
                        "end": 232,
                        "text": "Figure 2",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Terminators",
                "sec_num": "2.1"
            },
            {
                "text": "In order to record the derivation from A (fl3,1 ... 3,k) it would be sufficient to store A and 3'1 .. \u2022 3,k if we could also access the entry that records the derivation from At (fl3,t).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Terminators",
                "sec_num": "2.1"
            },
            {
                "text": "In the entry for ~?, using a pointer to the entry for At (fl3,t) would enable the recovery of the stack below the top k symbols, 3,1 \u2022 .. \"Yk. However, this scheme works well only when k _> 2. For instance, when k = 1, suppose we recorded only A, 3,1, and a pointer to entry for At (fl3,t). Suppose that we are looking for the symbol below 3,1, i.e., the top of ft. Then it is possible that in a similar way the latter entry could also record just At~ 3,t, and a pointer to some other entry to retrieve ft. This situation can occur arbitrarily many times.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Terminators",
                "sec_num": "2.1"
            },
            {
                "text": "Consider the derivation depicted in Figure 3 . In this derivation we have indicated the branch containing only the distinguished descendants. We will assume that the node labeled D (f13,, ..-3,k-13,~ .-. 3/~n ,) is the closest distinguished descendant of C (fl3,1..-3,k-13,~) such that every node between them will have a label of the form C' (fl\"Yl-., 3,k-13,~ O/) where len (~') > 1. Therefore, any node between that labeled C (fl3,1..-3,k-13,~) and B(fl3,1...3,rn) will have a label of the form C\" (fl3,1..-\"~k-10/') where fen (c~\") > 1. Now the entries representing derivations from both A(fl3,1... 3,k-13,k) and C (fl3,1... 3,k-13,~) could point back to the entry for the derivation from At (fl3,t), whereas the entry for C' (fl3,1 ...3,k-13,~c~') will point back to the entry for",
                "cite_spans": [
                    {
                        "start": 452,
                        "end": 467,
                        "text": "B(fl3,1...3,rn)",
                        "ref_id": null
                    },
                    {
                        "start": 603,
                        "end": 612,
                        "text": "3,k-13,k)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 36,
                        "end": 44,
                        "text": "Figure 3",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Terminators",
                "sec_num": "2.1"
            },
            {
                "text": "We shall now formalize these notions by defining a terminator.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "A",
                "sec_num": null
            },
            {
                "text": "Recovering the rest of stack-1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 2",
                "sec_num": null
            },
            {
                "text": "Recovering the rest of stack-2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 3",
                "sec_num": null
            },
            {
                "text": "v v",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 3",
                "sec_num": null
            },
            {
                "text": "Definition of a Terminator.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 4",
                "sec_num": null
            },
            {
                "text": "Suppose that we have the derivation tree in Figure 4 that depicts the following derivation:",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 44,
                        "end": 52,
                        "text": "Figure 4",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "A (fl3q ... %-17) ~ uB (fl'Ya ... q/k--lq/k.'' q/m) W uAt (flq/t) As (O~s) w uvw or similarly: A (flq/1\"'-q/k-lq/) uB (flq/1... q/k-lq/i.., q/m) W uAs (Ols) At (flq/t) w l~ V W",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "where the following conditions hold 2<k<m",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "The nodes labeled B (flq/1 ... q/k-lq/k . . . q/m) and At (flq/t) are distinguished descendants of the node labeled A (flq/1 ... q/k-lq/) in the respective trees.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "For any distinguished descendent labeled C (c~') between the nodes labeled A (flq/1... \")~k-lq/) and B (flq/1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "-. q/k-lq/k''' q/m), O/ is of the form flq/1 \u2022 \u2022 \u2022 q/kC~",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "where len (c~) > 1. Note that the nodes labeled a (flq/1... q/k-lq/) and B (flq/1... q/k-lq/k''\" q/m) need not be different.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "The node labeled At (flq/t) is the k-terminator of the node labeled A (flq/1 ... q/k-lq/).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "When it is clear from context, rather than saying that a node is a terminator of another we will assume that terminators have been defined on objects that participate in a derivation as well. For instance, in the above derivations, we will say that At (flq/t) is the k-terminator of A (fl71 ... 7k-l\"Y). Also when the derivation is clear from context, we will omit the mention of the derivation (or derivation tree). Additionally, we will say that a node (object) has a terminator, if it has a k-terminator for some k.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "We will now state some properties of terminators that influence the design of our recognition algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.4",
                "sec_num": null
            },
            {
                "text": "Given a grammar, G, define MCL(G) (Maximum Change in Length) as:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.5",
                "sec_num": null
            },
            {
                "text": "MCL(G) = max { m ] A (.. q/1. . . q/m) --* T1Ap ('\" ~p) T2 is a production of G }",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.5",
                "sec_num": null
            },
            {
                "text": "Henceforth, we will write MCL since the grammar in question will always be known from context.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.5",
                "sec_num": null
            },
            {
                "text": "In a derivation tree, if a node (say ~) has a k-terminator (say ~t) then ~t is a distinguished descendant of ~/. If the node ~/is labeled A (flc~) (where len (c~) = k) then the node 7/t must be labeled A t (flq/t) for some At C VN and q/t ff VI. Furthermore, 2 < k < MCL.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.1",
                "sec_num": null
            },
            {
                "text": "In a derivation tree, if a node has a k-terminator then it has a unique terminator.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.2",
                "sec_num": null
            },
            {
                "text": "If ~/is the node in question then we are claiming here that not only does it have a unique k-terminator but also that there does not exist k ~ with k' ~ k such that ~ has a kMerminator. To see why this is the case, let some node ~? have a k-terminator (for some k), say ~t. Using Observation 2.1 we can assume that they are labeled A (fl~l ... ~k-l\"Y) and At (flq/t), respectively, where we have (k-1) > 1. From the definition of terminators we can assume that the parent of the terminator, ~/t, is a node (say ~') that has a label of the form B (fl3'1 ... \"/k-l\"~k... \"Ym). Since (from the definition of terminators) every node between ~ and 7/~ (inclusive) must have a label of the form C (fl'Yl -.. \")'k-la ~) where len (a ~) >_ 1, it immediately follows that Tit is the closest distinguished descendant of such that the length of the stack in the object labeling ~]t is strictly less than the length of the stack in the object labeling ~/. From this, the uniqueness of terminators follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.2",
                "sec_num": null
            },
            {
                "text": "Consider the derivation A (fl\"Yl ... \"Yk-l\"~) ~ uAt (fl\"Yt) w ~ uvw where At (fl'~t) is the k-terminator of A (fl~/1---'Tk-l\"Y). Then for any fl' and v', if At (fl'~'t) ~ v' then we have the derivation A (fl'~l ... \"/k-~\"/) ~ uAt (fl\"Yt) w ~ uv'w where At (fl\"~t) is the k-terminator of A (fl\"~l ... 3~k-~'Y).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.3",
                "sec_num": null
            },
            {
                "text": "This follows from the fact that the derivation of uAt (fl\"yt) w from A (fl'Yl ... \"Yk-l\"7) is independent of ft. Therefore we can replace At (fl')'t) ~ v by At (fl'\"/t) =~ v'. This is a very important property that is crucial for obtaining polynomial-time algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.3",
                "sec_num": null
            },
            {
                "text": "Note that not all nodes have terminators. For example, if a node labeled A (a) is the parent of a node labeled a (i.e., corresponding to the use of the production A (a) --* a where a is a terminal symbol) then obviously this node does not have a terminator.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.3",
                "sec_num": null
            },
            {
                "text": "Given a grammar, G, we define MTL(G) (Maximum Length in, Terminal production) as:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.6",
                "sec_num": null
            },
            {
                "text": "MTL(G) = max { len (a) ] A (a) --* c is a production of G where ~ c VT (_J{\u00a2} }.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.6",
                "sec_num": null
            },
            {
                "text": "As in the case of MCL, we will use MTL rather than MTL(G).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2.6",
                "sec_num": null
            },
            {
                "text": "In the derivation A (a) ~ w if len (a) > MTL then A (a) has a terminator.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.4",
                "sec_num": null
            },
            {
                "text": "There must be at least two steps in the above derivation since len (a) > MTL.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.4",
                "sec_num": null
            },
            {
                "text": "However, we can assume that the node (say 7) in question labeled by the object 1 A (a) has a distinguished descendant, say ~/~, with label B (fl) such that B (fl) ~ \u00a2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.4",
                "sec_num": null
            },
            {
                "text": "Therefore, len (fl) <_ MTL and we may rewrite w as u\u00a2v. Since fen (a) > len (fl) we can find the closest distinguished descendant of ~/labeled C (a ~) for some C, a ~ such that len (a ~) < fen (a). That node is the terminator of ~] from the arguments made in Observation 2.2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.4",
                "sec_num": null
            },
            {
                "text": "The above observations will be used in the following sections to explain the way in which we represent derivations in the parsing table. We conclude this section with an observation that has a bearing on the steps of the recognition algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.4",
                "sec_num": null
            },
            {
                "text": "Consider the following derivation. a (fl'~l\"\"\" \"/k-l)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.5",
                "sec_num": null
            },
            {
                "text": "TIA. (fl~/l... ')'k-l\"Yk) T2 l~llap (fl71... 7k-17k) U2 Ul Vl At (fl'/t) v2u2 Ul Vl WV2U2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.5",
                "sec_num": null
            },
            {
                "text": "where Ap (fiVe... \"Yk-l'Yk) is the distinguished child of A (f17~... ')'k-l) and At (flVt) is the k-terminator of Ap (fl71..-7k-l\"Yk). At (fl~t) is the (k -1)-terminator of A (fl71 .",
                "cite_spans": [
                    {
                        "start": 6,
                        "end": 27,
                        "text": "Ap (fiVe... \"Yk-l'Yk)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.5",
                "sec_num": null
            },
            {
                "text": "--\")'k-l)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 2.5",
                "sec_num": null
            },
            {
                "text": "if and only if k > 2. If k = 2 then A (fl71) has a terminator if and only if At (fl'Tt) does. In fact, in this case, if At (fl'Tt) has a kMerminator then that terminator is also the k~-terminator of A (flVt). This can be seen by considering the derivation shown in Figure 3 and noting the sharing of the terminator of C (fl3'1.-. 7k-17~) and A (fl\"/1-.. 7k-l\")/k) \u2022",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 265,
                        "end": 273,
                        "text": "Figure 3",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Observation 2.5",
                "sec_num": null
            },
            {
                "text": "As in the CKY algorithm we will use a two-dimensional array, P, such that if A (c~)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms",
                "sec_num": "3."
            },
            {
                "text": "ai.. \u2022 ai+d-1 then a representation of this derivation will be recorded with an encoding of A ((~) in P",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms",
                "sec_num": "3."
            },
            {
                "text": "[i, d].",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms",
                "sec_num": "3."
            },
            {
                "text": "Here we assume that the given input is al ... an. We start our discussion by considering the data structures we use to record such objects and derivations from them.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms",
                "sec_num": "3."
            },
            {
                "text": "We mentioned earlier that the stack in an object can be unboundedly large. We must first find a compact way to store encodings of such objects whose size is not bounded by the grammar. In this section we provide some motivation for the encoding scheme used in the recognition algorithm by considering the bottom-up application of the rule and the encoding of the primary constituent:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "A (..'y1. . .'~m) --* Ap (\"~/p) As (,~s)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "The Head. An object with nonterminal Ap and top of stack \"Tp will match the primary category of this rule. Thus, the first requirement is that at least this much of the object must be included in every entry since it is needed to determine if the rule can apply. an) will be stored in the array element P {i, dp] in our CKY-style recognition algorithms. Now consider the encoding of Ap (fl'yp) for some sufficiently long fl-yp. While the head, lAp, ~p), of the entry is sufficient to determine whether the object in question can match the primary category of the rule, we will need to store more information in order that we can determine the content of the rest of the stack. In the above production, if m = 0 then the combination of Ap (fl~/p) and As (~s) results in A (fl). In order to record the derivation from A (fl), we need to know the top symbol in the stack fl, i.e., the symbol below the top of the stack associated with the primary constituent. We need to recover the identity of this symbol from the encoding of the primary category. This is why we introduced the notion of terminators. As mentioned in Section 2.1, terminators can be used to access information about the rest of the stack. In the encoding of Ap (fl'yp), we will store information that allows us to access the encoding of its terminator. The part of the entry encoding the terminator will be called terminator pointer.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "The Middle. Note that the object Ap (fl,yp) (in the derivation Ap (fl3'p) =~ ai... ai+dp-1) can have a k-terminator where k is between 2 and MCL. Therefore, from Observation 2.1 it follows that the terminator-pointer can only be used to determine the (k+l) st symbol from the top. Therefore, assuming that fl = fl\"yl \u2022 .. \"Yk-1, the terminator-pointer will allow us to access fl~. (Recall from the definition, a k-terminator of A (fl\"yl ... \"Yk-13'p)",
                "cite_spans": [
                    {
                        "start": 77,
                        "end": 91,
                        "text": "ai... ai+dp-1)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "will have the form At (fl\"Yt). Thus the (k + 1) st symbol from the top in A (fl-yp) is the same as the symbol below the top of the stack of the terminator.) Thus, we will need to record the string \"yl -'' \"Yk-1 in the encoding of as well. This part of the entry will be called the middle.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "To summarize, the entry stored in P [i, dp] (where fl\"yl... \"Yk-l\"Yp is assumed to be sufficiently long that we know A m (fl'71-.. 7k-l\"Yp) is guaranteed to have a terminator) will have a head, (Ap,-yp); and a tail comprised of a middle, \"Yl..-'Yk-1; and a terminator-pointer. Note that the length of the middle must be at least one, but at most MCL -1, since from Observation 2.1, we know 2 < k < MCL. We will call an entry of this kind a terminator-type entry.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "We will now discuss what we need to store in order to point to the terminator. Suppose we would like to record in P [i,d] the derivation of ai...ai+d-1 from A (fl'Yl... 7k-l\"Y) as shown below. We assume that At (fl'yt) is the terminator in this derivation.",
                "cite_spans": [
                    {
                        "start": 116,
                        "end": 121,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "a (fl\"/1...'Yk-l\"Y) ai. .. at_lAt (fl')'t) at+dt . . . ai+d-1 ai \u2022 \u2022 \u2022 at-l at \u2022 \u2022 \u2022 at+dt-l at q-dt \u2022 \u2022 \u2022 ai+d-1 ~-ai \u2022 \u2022. ai+d-1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "From Observation 2.3, it follows that it would be sufficient to use ((at~ \"Ytl~ [t~ dt]) as the terminator-pointer. This is because any entry with the head (At~ \")'tl in P It, dt] will represent in general a derivation At (fl\"Yt) ~ at... at+dr-1. This not only matches the above case, but even if fl' ~ fl, from the Observation 2.1, we have",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "A (fl'\"/1... \"Yk-lq/) ~ ai... at-lAt (fl'\"/t) at+dr.., aiq-d--1 ~ ai... ai+d-1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "Thus, the use of the head information (plus the two indices) in the terminator-pointer captures the essence of Observation 2.3. It is this structure-sharing that allows us to achieve polynomial bounds for space and time. Note that the string derived from the terminator, at...at+dr-i, is a substring of ai...ai+d-1. In such a case, i.e., when i G t and i+ t >>_ t + dr, we will say that /t, dt/ <_ {i~dl. We define {t, dt/ < {i, dl if {t, dtl <_ {i, dl and {t, dtl # {i, dl. Since any terminator-type entry in P [i,d] ",
                "cite_spans": [
                    {
                        "start": 512,
                        "end": 517,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Anatomy of an Entry",
                "sec_num": "3.1"
            },
            {
                "text": "Given a grammar, G, define MSL(G) (Maximum Secondary constituent's stack Length)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3.1",
                "sec_num": null
            },
            {
                "text": "as MSL(G) = max { len (as) I As (e~s) is the secondary constituent of a production } Henceforth we will use MSL rather than MSL(G).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3.1",
                "sec_num": null
            },
            {
                "text": "We now consider the question of when a terminator-type entry is appropriate. Of course, if A (~) ~ ai... ai+d-1 we could store such an entry in P Ii, dpl only when A (c~) has a terminator in this derivation. From Observation 2.4 we know that if len (c~) > MTL then there exists a terminator of A (~) in this derivation. However, it is possible that for some grammar MSL > MTL. Therefore even when len (c~) > MTL (i.e., the object has a terminator) A (~) can still match the secondary category of a rule if len (c~) G MSL. In order to verify that an object matches the secondary category of a rule we need to consider the entire stack in the object. When A (~) ~ ai... ai+d-1 and length of ~ does not exceed MSL, it would be convenient to store A as well as the entire stack c~ because such an object can potentially match a secondary category of a rule. To be certain that such an object is stored in its entirety when len (~) < MSL, the terminator-type entry can only be used when len (c~) > max(MSL~ MTL). However, we prefer to use the terminator-type entry for representing a derivation from A (~) only when its terminator, say At (fl), is such that len (fl) >_ max(MSL~ MTL) rather than when len (c~) > max(MSL~ MTL). Again, we point out that this choice is made only for convenience and because we feel it leads to a simpler algorithm. The alternate choice could also be made, which would lead to a slightly different algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3.1",
                "sec_num": null
            },
            {
                "text": "Define the constant TTC (Terminal-Type Case) as TTC = max(MSL MTL). In a derivation A (fl71 ... 7k) ~ W we will say that A (flY1 -.. Vk) has the TC-property iff it has a k-terminator, say At (flTt), such that len (flVt) _> TTC.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3.2",
                "sec_num": null
            },
            {
                "text": "If A (fl31 ... 3k) ~ ai... ai+d_l, where A (fl31 .-. 3k) does not have the TC-property then we record the object in its entirety in P Ii~ d]. In order for such an entry to have the same format as the terminator-type entry, we say that the entry has a head /A~ 3k); a tail with a middle 31.-. 7k-1 and a nil terminator-pointer. Note that in this case the middle can be an empty string; for instance, when we encode A (V) ~ ai.. \u2022 ai+d-1. In general, if c~ = f13 then we say top (~) = 3 and rest (c~) = ft. If o~ = \u00a2 then we say that top (c~) = rest (c~) ~-~.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3.2",
                "sec_num": null
            },
            {
                "text": "To summarize, the structure of an entry in P Ii, d I is described by the following rules.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3.2",
                "sec_num": null
            },
            {
                "text": "An entry consists of a head and a tail.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "\u2022",
                "sec_num": null
            },
            {
                "text": "\u2022 A head consists of a nonterminal and a stack symbol.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "\u2022",
                "sec_num": null
            },
            {
                "text": "\u2022 A tail consists of a middle and a terminator-pointer. The exact nature of the middle and the terminator-pointer are as given below.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "\u2022",
                "sec_num": null
            },
            {
                "text": "The terminator-pointer may be of the form (IAt~ 7tl~ [t~dtl) where At E VN~ 3t E W I and It~ dtl <_ li~ d). In this case, the middle is a string of stack symbols of length at least one. This form of a terminator pointer is used in the encoding of a derivation from an object if its terminator has a stack length greater than or equal to TTC. Recall that we had called this type of an entry a terminator-type entry.",
                "cite_spans": [
                    {
                        "start": 53,
                        "end": 60,
                        "text": "[t~dtl)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "--",
                "sec_num": null
            },
            {
                "text": "A terminator-pointer can be a nil. Then the middle is a (possibly empty) string of stack symbols. However, the length of the middle is less than TTC + MCL -1. This form of a terminator pointer is used in the encoding of a derivation from an object if it does not satisfy the TC-property; i.e., either it has no terminator or if the terminator exists then its stack length is less than TTC.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "--",
                "sec_num": null
            },
            {
                "text": "Since the full algorithm involves a number of cases, we develop it in stages by restricting the forms of productions. The first algorithm that considers the most restricted form of productions introduces much of what lies at the core of our approach. Next we relax these restrictions to some degree. After giving the algorithm at this stage, we switch to discuss how this algorithm can be adapted to yield one for CCG. Later, in Section 5, we consider further relaxation of the restrictions on the form of LIG productions, which can help us produce an algorithm for TAG.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "Regardless of which set of restrictions we consider, in every algorithm we shall establish that the following proposition holds.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "Proposition 3.1 \u2022 ((at ~k) (')'1.-. \"Yk-1, ((at,,,/t), [t, dt]))) E P[i,d] if and only if for some fl c v~, a (fl~'l... \"Yk-l\"/k) ~ ai... at-la (fl\"/t) at+dt-1...ai+d-1 ai. . .ai+a-1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "where At (fl\"/t) is the k-terminator of A (fl\"/1 ''' \"Yk) and len (fl'Yt) >_ TTC.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "\u2022 ((A,'yk) (3'1...Tk-1,nil)) E P[i,d] ifand only if a (')'1... q/k-lq/k) ~ ai...ai+d-1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "where in this derivation A (\"/1 ... \"Yk-l'Yk) does not have the TC-property.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "3.2.1 Algorithm 1. Recall that the general form of rules that are to be considered are as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "1. A (c~) --* c where e \u00a2 {e} U VT, and len (c~) > 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "2. A(..'y~. .'rm)~ Ap(..'~p)As(~s) 3. a(..~l...\"ym)----~ as(ozs)ap (..\"fp).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "4. a (\"~l...3'm) ~Ap (\"3'p) .",
                "cite_spans": [
                    {
                        "start": 5,
                        "end": 16,
                        "text": "(\"~l...3'm)",
                        "ref_id": null
                    },
                    {
                        "start": 21,
                        "end": 27,
                        "text": "(\"3'p)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "At this stage we assume that the following restrictions hold of the above rules.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "In the first type of production we assume that e c VT and len (c~) > 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "Thus MTL > 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "len (C~s) _> 1 in productions of type 2 and type 3, i.e., MSL > 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "There are no productions of type 4.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "We will now give the following rules that specify how entries get added in the parsing array. The control structure of the algorithm (a CKY-style dynamic programming structure) will be added later. We assume that the input given is al ... an, where n>l.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithms for LIG",
                "sec_num": "3.2"
            },
            {
                "text": "In the initialization phase of the algorithm we store lexical objects (objects deriving a terminal symbol in one step) entirely in a single entry. In other words,",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Initialization Phase",
                "sec_num": null
            },
            {
                "text": "Rule 1.L A (c~) ---~ a a = ai l<i<n ( {A, top (c~)} (rest (ee), nil)) \u00a2 P[ i, 1]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Initialization Phase",
                "sec_num": null
            },
            {
                "text": "Here productions of type 2 and type 3 will be considered. Let us assume the presence of the following production in the grammar: A (.. \"Yl ... \"/m) --+ Ap (.. %) As (o~s). 5",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Inductive phase",
                "sec_num": null
            },
            {
                "text": "Suppose that while considering which entries are to be included in P [i, d] we find the following for some dp, ds such that dp + ds = d.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Inductive phase",
                "sec_num": null
            },
            {
                "text": "\u2022 The entry ((Ap,,ypl (flp,tpp) From the presence of the two entries specified above (and the derivations they rep-",
                "cite_spans": [
                    {
                        "start": 12,
                        "end": 31,
                        "text": "((Ap,,ypl (flp,tpp)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Inductive phase",
                "sec_num": null
            },
            {
                "text": "resent) we have A (flflp'Yl ... 7m) ~ Ap (flflp'yp) As (c~s) ~ ai... ai+d-1. This derivation",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Inductive phase",
                "sec_num": null
            },
            {
                "text": "must be recorded with an entry in P [i, d] . The content of the entry depends on several factors: the value of m; whether or not the terminator-pointer in the entry for the primary constituent (i.e., tpp) is nil; and the length of the middle in this entry (i.e., tip).",
                "cite_spans": [
                    {
                        "start": 36,
                        "end": 42,
                        "text": "[i, d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Inductive phase",
                "sec_num": null
            },
            {
                "text": "These determine whether or not the new entry will be a terminator-type entry. We have cases for m = 0, m = 1 and m _> 2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Inductive phase",
                "sec_num": null
            },
            {
                "text": "The new object to be stored is A (flflp). The top of the stack in this object can be obtained from the stack associated with the primary constituent. How this is done depends on whether the entry encoding the primary constituent is of terminator type or not.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "CASE WHEN m = 0",
                "sec_num": null
            },
            {
                "text": "This means that the primary constituent has been represented in its entirety; i.e., the primary constituent is Ap (flpTp). Since tpp = nil the primary constituent does not satisfy the TC-property (i.e., it does not have a terminator with a stack of length greater than or equal to TTC), the new constituent too cannot be encoded using a terminator-type entry. Therefore, Rule 2.ps.L (lAp, 3'pl (tip, nil) ",
                "cite_spans": [
                    {
                        "start": 383,
                        "end": 388,
                        "text": "(lAp,",
                        "ref_id": null
                    },
                    {
                        "start": 389,
                        "end": 399,
                        "text": "3'pl (tip,",
                        "ref_id": null
                    },
                    {
                        "start": 400,
                        "end": 404,
                        "text": "nil)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": ") \u00a2 P[i, dp] ((As, top(c~s)) (rest(o~s),nil) ) C P[i +dp, d -dp] ( IA, t\u00b0P (flp) l (rest (flp),nil) ) E P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "The following rule is the counterpart of Rule2.ps.L 6 that corresponds to the use of the production A (..) ~ As (C~s) Ap (.. 7p).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "Rule 2.sp.L ( (As, top(c~s) ",
                "cite_spans": [
                    {
                        "start": 12,
                        "end": 27,
                        "text": "( (As, top(c~s)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": ") (rest(c~s),nil) ) \u2022 P[i, ds] ((Ap, Vp ) (tip,nil)) \u2022 P[i + ds,d-ds] ((A, top (tip)) (rest (tip),nil) ) \u2022 P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "When m = 0 and tpp ~ nil",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "Let the entry for the primary constituent be ((Ap, 7p) (tip, ((At, 7t) , It, dr]))). Since the primary constituent is Ap (flflpTp) we will assume that its terminator is At (fl'Yt) where len (flVt) > TTC. Note also that len (flp'yp) > 2. The entry for the new object (A (flflp)) is determined based on whether len (tip) = 1 or len (tip) > 1. In the latter case the len (flpVp)-terminator of the primary constituent is the len (&)-terminator of the new object. This is not so in the former case, as noted in Observation 2.5.",
                "cite_spans": [
                    {
                        "start": 45,
                        "end": 50,
                        "text": "((Ap,",
                        "ref_id": null
                    },
                    {
                        "start": 51,
                        "end": 54,
                        "text": "7p)",
                        "ref_id": null
                    },
                    {
                        "start": 55,
                        "end": 60,
                        "text": "(tip,",
                        "ref_id": null
                    },
                    {
                        "start": 61,
                        "end": 66,
                        "text": "((At,",
                        "ref_id": null
                    },
                    {
                        "start": 67,
                        "end": 70,
                        "text": "7t)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "Considering the latter case first, i.e., len (tip) > 1, we may write tip as 71...'Yk-lVk where k > 2. Since in this case the new object and the primary constituent have the same terminator and since the primary constituent has the TC-property (tpp ~ nil),",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "the new object must also be encoded with a terminator-type entry. Thus we have the following rule:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "Rule 3.ps.L ((Ap,~/p)('y1...3%tpp)) \u2022P[i, dp] tpp = ((At,vt), [t, dt]) ,k >_ 2 ((As, top (c~s)) (rest (c~s), nil)) \u2022 P [i + dp, d -dp] ((A,\"Ykl (\"Y1...Tk-l,tpp)) cP[i,d 1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "Henceforth we shall give the ps versions of the rules only and omit sp versions. Now let us consider the case when len (tip) = 1. Rewriting tip as 71, the entries represent derivation for fl E V~ (len (fl'yl) = len (fl\"/t) > TTC).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "a (ti\"/1) ~ ap (ti\"/l\"/p) As (0@) ai . . . at-l At (tiTt ) at+a,.., ai+ap-l As (C~s) ai . . . at_ lat . . . at+d t_ lat+dt \u2022.. ai+dp_ laiq-d p ... ai+d_l",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "where At (ti'Yt) is the 2-terminator of Ap (ti\"/l\"Yp)-From Observation 2.5 it follows that if At(tiVt) has a terminator then the terminator of A(ti'yl) in this derivation is the same as the terminator of At (fl'Yt); and if At (fl'Yt) has no terminator then neither does A (ti'Yl). Additionally, in this derivation A (ti'yl) satisfies the TC-property if and only",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "if At (ti'Yt) has the TC-property. That is, we should use a terminator-type entry to record this derivation from A (ti'Yl) if and only if a terminator-type entry has been used for At (tiTt). Since these two objects share the same terminator (if it exists) the terminator-pointer must be the same when we record derivations from them. Therefore, suppose we use the terminator-pointer of ((Ap, \u00bd) (tip, ((At, \"Yt) , [t, dt] ))) to locate an entry ((At, \"Yt) (tit, tPt)) \u2022 P It, dr]. This would suggest the addition of the entry (IA, \"/1)(tit, tpt) ) to P [i,d] , regardless of whether or not tPt = nil. However, we give the two cases (tpt = nil or tPt = (IAr, %1, [r, dr] ) for some At, %, r, dr) in the form of two different rules. This is because (as we shall see later) these two rules will have to appear in different points of the control-structure of the parsing algorithm. ",
                "cite_spans": [
                    {
                        "start": 395,
                        "end": 411,
                        "text": "(tip, ((At, \"Yt)",
                        "ref_id": null
                    },
                    {
                        "start": 414,
                        "end": 421,
                        "text": "[t, dt]",
                        "ref_id": null
                    },
                    {
                        "start": 553,
                        "end": 558,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 652,
                        "end": 657,
                        "text": "(IAr,",
                        "ref_id": null
                    },
                    {
                        "start": 658,
                        "end": 661,
                        "text": "%1,",
                        "ref_id": null
                    },
                    {
                        "start": 662,
                        "end": 665,
                        "text": "[r,",
                        "ref_id": null
                    },
                    {
                        "start": 666,
                        "end": 669,
                        "text": "dr]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m = 0 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "\u00a2 P [i,d~,] ((As, top (c~s) ) (rest (C~s), nil)) \u00a2 P [i+dp,d-dp] ((At, \"~/t) (fit, tPt) )",
                "cite_spans": [
                    {
                        "start": 4,
                        "end": 11,
                        "text": "[i,d~,]",
                        "ref_id": null
                    },
                    {
                        "start": 53,
                        "end": 64,
                        "text": "[i+dp,d-dp]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "( (Ap, vp) (71, ( (At, 7t) , [t, dt] ) ) )",
                "sec_num": null
            },
            {
                "text": "P[t, at] tpt = ((Ar,'Yr), Jr, dr]) ((A, 7\"/1) (flt,tpt) ) E P[i,d] CASE WHEN m --1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "( (Ap, vp) (71, ( (At, 7t) , [t, dt] ) ) )",
                "sec_num": null
            },
            {
                "text": "The length of the stack in the new object is equal to that of the primary object. In fact, the terminator of the primary object (if it exists) is the same as the terminator of the new object, and when the primary object has no terminator neither does the new object. Therefore the encoding of the new object can easily be derived from that of the primary object by simply modifying the head (to change the top of the stack symbol). Thus we have:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "( (Ap, vp) (71, ( (At, 7t) , [t, dt] ) ) )",
                "sec_num": null
            },
            {
                "text": "Rule 6.ps.L ((Ap,'Tp) (tip, nil)) \u00a2 P[i, dp] ((As, top(c~s)) (rest(c~s),nil)) c P [i+dp,d-dp] ((A,\")'I) (tip, nil)) \u00a2 P [i,d] should be recorded with the use of a terminator-type entry. We use the terminator-type entry only when len (tip3'p) ~ TTC. In order to determine the length of this stack we have to use the entry for the primary constituent (i.e., (IAp,.Tp)(tip, tpp)lE PIi, dp]) and consider whether this is a terminator-type entry or not (i.e., whether tpp = nil or not).",
                "cite_spans": [
                    {
                        "start": 82,
                        "end": 93,
                        "text": "[i+dp,d-dp]",
                        "ref_id": null
                    },
                    {
                        "start": 120,
                        "end": 125,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "( (Ap, vp) (71, ( (At, 7t) , [t, dt] ) ) )",
                "sec_num": null
            },
            {
                "text": "Therefore the length of the stack of the terminator of the primary constituent is greater than or equal to TTC. This means that stack length of the primary constituent (the terminator of the new object) exceeds TTC. Thus we have the following rule:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m _> 2 and tpp ~ nil",
                "sec_num": null
            },
            {
                "text": "Rule 8.ps.L ({Ap,'Tp) (tip, tpp) ) \u00a2 P[i, dp] tpp = (Iat,'~t), It, dr]) ({As, top (C~s)) (rest (as), nil)) E P[i +dp, d -dpl (/A, ~m) (\")/1.-. \"/m-l, ( {Ap, \"yp) , [i, dp]) ) ) c P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m _> 2 and tpp ~ nil",
                "sec_num": null
            },
            {
                "text": "The primary constituent (which is the terminator of the new object) should be represented in its entirety. Therefore, in order to determine whether we have to encode the new object with a terminator-type entry or not, we have to look at the entry for the primary constituent. Thus we obtain the following rules:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m _> 2 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "Rule 9.ps.L len (tip'yp) < TTC ( IAp, 3, pl (tip, nil) ) E P[i, dp] ((As, top (as)) (rest (as), nil)) E P [i + dp, d -dp] ( {A, ~m) (tipVl . . . Tm-l,nil) ) E P [i,d] Rule 10.ps.L len (tip-yp) > TTC ( (Ap, 7p) (tip, nil)) c P[i, dp] ( IAs, top (as)) (rest (~s), nil)) E P [i + dp, d -dp] ((A, \"Ym) ('Yl... \"/m-l, (lAp, \"/p) , [i, dp] ) ) ) C P [i,d] In the discussions that follow, we find it convenient to refer to the entries mentioned in the above rules as either antecedent entries (or entries that appear in the antecedent) of a rule or consequent entry (or entry that appears in the consequent) of a rule. For example, (lAp, q/pl (tip, nil) ) in PIi, dpl and ( IAs,top(e~s)l (rest (c~s),nil) ) in PIi + dp,d -dpl are the antecedent entries of Rule 10.ps.L and ( IA, \"Yml ('Y'\"\" \"Ym--l~ ( I ap~ \"~p I' [i, dp] ",
                "cite_spans": [
                    {
                        "start": 31,
                        "end": 37,
                        "text": "( IAp,",
                        "ref_id": null
                    },
                    {
                        "start": 38,
                        "end": 40,
                        "text": "3,",
                        "ref_id": null
                    },
                    {
                        "start": 41,
                        "end": 49,
                        "text": "pl (tip,",
                        "ref_id": null
                    },
                    {
                        "start": 50,
                        "end": 54,
                        "text": "nil)",
                        "ref_id": null
                    },
                    {
                        "start": 161,
                        "end": 166,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 344,
                        "end": 349,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 625,
                        "end": 646,
                        "text": "(lAp, q/pl (tip, nil)",
                        "ref_id": null
                    },
                    {
                        "start": 766,
                        "end": 814,
                        "text": "( IA, \"Yml ('Y'\"\" \"Ym--l~ ( I ap~ \"~p I' [i, dp]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m _> 2 and tpp = nil",
                "sec_num": null
            },
            {
                "text": ") ) )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m _> 2 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "that is added to P [i, d I is the entry in the consequent of Rule 10.ps.L.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "When m _> 2 and tpp = nil",
                "sec_num": null
            },
            {
                "text": "We will start by giving a simple control structure for the recognition algorithm that follows the dynamic programming style used in the CKY algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Control Structure",
                "sec_num": "3.3"
            },
            {
                "text": "In this section we modify the notation for entries slightly. In the above discussion, the terminator-pointer of a terminator-type entry contains a pair of indices representing input positions. Thus, in effect, P is a four-dimensional array. As an alternative to saying that (( A, 3,) (fl, (CA', 3\"), [t,d;]))) is in P[i,d] we will sometimes say (C A, -y)(fl, (A', 3/))) is in P [i, d] [t, dt] . Also as an alternative to saying (C A, oe)(fl, nil)) is in P[i,d] we will sometimes say ((A, c,) (fl, nil)) is in P [i,d] [O,O] . Thus P can be considered to be an array of size n x n x (n + 1) x (n + 1).",
                "cite_spans": [
                    {
                        "start": 378,
                        "end": 384,
                        "text": "[i, d]",
                        "ref_id": null
                    },
                    {
                        "start": 385,
                        "end": 392,
                        "text": "[t, dt]",
                        "ref_id": null
                    },
                    {
                        "start": 511,
                        "end": 516,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 517,
                        "end": 522,
                        "text": "[O,O]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Control Structure",
                "sec_num": "3.3"
            },
            {
                "text": "In the specification of the algorithm ( Figure 5 ) we will not restate all the rules we discussed in the previous section. Instead we will only indicate where in the control structure each rule fits. As an example, when we state \"Use Rule 2.ps.L with dp = d\" within the i, d, and d' loops we mean the following: for current values of i, d, and d' (and hence dp, ds) consider every production of the form A (.. \"Yl ... 7m) --+ Ap (.. 7p) As (as) with m = 0. For each such production, look for entries of the form ((Ap, 7p) (tip, nil)) E P [i, dp] [0,0] for some tip and ( (As, top (as) ) (rest (as), nil) ) E P [i + dp, d -dp] [0,0]. In the event we find such entries, we add ((A, top (tip)) (rest (flp),nil)) to P [i,d] [0,0] if it is not already there.",
                "cite_spans": [
                    {
                        "start": 714,
                        "end": 719,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 40,
                        "end": 48,
                        "text": "Figure 5",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "The Control Structure",
                "sec_num": "3.3"
            },
            {
                "text": "Since the entries in P [i, d] have the form ( (A, -,/) (fl, (CAt, 3q) , It, dt] ) ) ) (where (t, dt) G (i,d)) or the form (CA,')')(fl, nil)), there are O(d 2) many entries in P [i,d] (where 1 G i < n and 1 G d G n -d). Thus space complexity of this algorithm is O(nd). Note that within the body within the r loop will be attempted for all possible values of i, d, d', t, dt, r, dr. Since the range of each loop is O(n), the time complexity is O(n7).",
                "cite_spans": [
                    {
                        "start": 23,
                        "end": 29,
                        "text": "[i, d]",
                        "ref_id": null
                    },
                    {
                        "start": 177,
                        "end": 182,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 358,
                        "end": 381,
                        "text": "i, d, d', t, dt, r, dr.",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Control Structure",
                "sec_num": "3.3"
            },
            {
                "text": "The asymptotic complexity of the above algorithm can be improved to O(n 6) with a simple rearrangement of the control structure. The key point here is that the steps involving the use of rules 5.ps.L and 5.sp.L can be split into two parts each. Consider, for example, the use of the Rule 5.ps.L, which is repeated below.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Control Structure",
                "sec_num": "3.3"
            },
            {
                "text": "Rule 5.ps.L (fit, ((Ar,'Yr) , [r, dr]))) E P [i,d] This rule corresponds to the use of the production A (..) ~ Ap (.. q/p) As (as). The values of i, d, d ', t, d t are necessary to determine the span of the substrings derived from the primary constituent and the secondary constituent, and the values of i, d, t, dt, r, dr are needed to locate the entry for the terminator, i.e., (CAt,,) ,t)(fit, (CAr,\"/r), [r, dr] ))) and to place the new entry in the appropriate parsing table element. That is, the values of r and dr are not required for the first part and the value of d' need not be known for the second part. This indicates that the second part need not be done within the loop for dq Therefore, we can modify the control structure in the following way. Within the t loop (which appears within the loops for d, i, d',dt) we find the entries for the primary and secondary constituents. Having found the two relevant entries, we must record the head of the new entry (A, tip) and the terminator-pointer of the primary constituent, i.e., (CAt, ~t), [t, dt] ). We can do this by using a two-dimensional array called TEMP where we store CA, q'l, At, 7t) . Outside the d' loop (and hence outside the loops for t and dt as well), but within the loops for i and d, we can have the loops that vary t, dt, r, dr (note (r, dr) < (t, dr)) in order to locate the entry for the terminator by using the information recorded in TEMP. Finally, having found the entry for the terminator we then store the resulting entry in P [i, d] . These steps are captured by the following rules. For a specific value of (i, d) we have",
                "cite_spans": [
                    {
                        "start": 12,
                        "end": 27,
                        "text": "(fit, ((Ar,'Yr)",
                        "ref_id": null
                    },
                    {
                        "start": 45,
                        "end": 50,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 154,
                        "end": 161,
                        "text": "', t, d",
                        "ref_id": null
                    },
                    {
                        "start": 380,
                        "end": 387,
                        "text": "(CAt,,)",
                        "ref_id": null
                    },
                    {
                        "start": 408,
                        "end": 415,
                        "text": "[r, dr]",
                        "ref_id": null
                    },
                    {
                        "start": 1053,
                        "end": 1060,
                        "text": "[t, dt]",
                        "ref_id": null
                    },
                    {
                        "start": 1139,
                        "end": 1142,
                        "text": "CA,",
                        "ref_id": null
                    },
                    {
                        "start": 1143,
                        "end": 1147,
                        "text": "q'l,",
                        "ref_id": null
                    },
                    {
                        "start": 1148,
                        "end": 1151,
                        "text": "At,",
                        "ref_id": null
                    },
                    {
                        "start": 1152,
                        "end": 1155,
                        "text": "7t)",
                        "ref_id": null
                    },
                    {
                        "start": 1515,
                        "end": 1521,
                        "text": "[i, d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Control Structure",
                "sec_num": "3.3"
            },
            {
                "text": "EP[i, dp] ((A,, top ( o~, ) ) (rest (c~), nil)) GP[i+dp,d-dp] ((At, \")'t) (fit, tpt) ) tpt = ((Ar,\")'r), [r, dr]) ((A, q'l)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": "Rule 5.i.ps.L ( (Ap, q/p) (71, ( (At, q/t) , It, dr]))) C P[i, dp] ((As, top (C~s)) (rest (C~s), nil)) e[i + clp, cl -G] (A, q/1,At, 7t) E TEMP[t, dt] Rule 5.ii.ps.L (a~\"/l~.,z~t,q/t) E TEMP[t, dt] ((At, q/t) (fit, ((Ar, q/r), [r, dr]))) C P[t, dt] ((A,q/1) (fit, ((Ar, q/r), [r, dr]))) C P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": "Similarly, we assume we have the pair Rule 5.i.sp.L and Rule 5.ii.sp.L corresponding to Rule 5.sp.L. This leads to the algorithm given in Figure 6 . In this algorithm we drop the sp rules and specify the ps rules only for the sake of simplicity.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 138,
                        "end": 146,
                        "text": "Figure 6",
                        "ref_id": "FIGREF10"
                    }
                ],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": "The correctness of Algorithm 2 can be established from the correctness of Algorithm 1 (which is established in Appendix A) and the following Lemma. ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": "(Ap, q/p) ('71, ((At, q/t), [t, dt]))) in P[i, dp];",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": "((As, top(c~s))(rest(c~s),nil)) in P [i+dp,d-dp] ; ((at, q/t) (flt~((ar, q/r It, dt] ; and the production A (..) --* Ap (.. q/p) As (~s). Using induction, we can establish that these entries exist if and only if (A, q/1,At~ q/t) is added to TEMP[t, dt] using Rule 5.ps.i.L (or Rule 5.sp.i.L) and ((A, q/1) (fit, ((Ar, q/r), Jr, dr]))) is added to P [i,d] using Rule 5.ii.ps.L.",
                "cite_spans": [
                    {
                        "start": 37,
                        "end": 48,
                        "text": "[i+dp,d-dp]",
                        "ref_id": null
                    },
                    {
                        "start": 51,
                        "end": 61,
                        "text": "((at, q/t)",
                        "ref_id": null
                    },
                    {
                        "start": 62,
                        "end": 76,
                        "text": "(flt~((ar, q/r",
                        "ref_id": null
                    },
                    {
                        "start": 77,
                        "end": 84,
                        "text": "It, dt]",
                        "ref_id": null
                    },
                    {
                        "start": 349,
                        "end": 354,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": ")~[Y~dr])) ) in P",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ap,',/p) (~I, ((At, q:t) , [t, dt]) ) )",
                "sec_num": null
            },
            {
                "text": "Combinatory Categorial Grammars (CCG) (Steedman 1985 (Steedman , 1986 are extensions of Classical Categorial Grammars in which both function composition and function application are allowed. In addition, forward and backward slashes are used to place conditions concerning the relative ordering of adjacent categories that are to be combined.",
                "cite_spans": [
                    {
                        "start": 38,
                        "end": 52,
                        "text": "(Steedman 1985",
                        "ref_id": "BIBREF11"
                    },
                    {
                        "start": 53,
                        "end": 69,
                        "text": "(Steedman , 1986",
                        "ref_id": "BIBREF10"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Combinatory Categorial Grammars",
                "sec_num": "4."
            },
            {
                "text": "The set of categories generated from a set, VN, of atomic categories is defined as the smallest set such that all members of VN are categories, and if cl, c2 are categories then so are (Cl/C2) and (el\\e2).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.1",
                "sec_num": null
            },
            {
                "text": "for i:= 1 to n do",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Algorithm 2 begin",
                "sec_num": null
            },
            {
                "text": "Use Rule 1 ford:=2tondo%dloop for i := 1 to n-d + 1 do % i loop begin Initialize TEMP It, dt] to ~ for all (t~ dt) ~ (i~ d)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Initialization phase",
                "sec_num": null
            },
            {
                "text": "fordp:=ltod-ldo %dploop Use Rule 2.ps.L, 6.ps.L, 9.ps.L, 10.ps.L for dt := dp -1 to 1 do % dt loop for t := i to i + dp -dt do % t loop Use Rule 3.ps.L, 4.ps.L, 5.i.ps.L, 7.ps.L, 8.ps.L % end of t loop % end of dt loop % end of dp loop for dt := d -1 to 1 do % dt loop for t := i to i + d -dt do % t loop for dr := dt -1 to 1 do for r := t to t + dt -dr do ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Initialization phase",
                "sec_num": null
            },
            {
                "text": "Here x,y, zl,... ,Zm are meta-variables and h,..-, [m E {\\, /}. For m --0 these rules correspond to function application and for m > 0 to function composition. Note that the set R contains a finite subset of these possible forward and backward rules; i.e., for a given CCG only some of the combinatory rules will be available.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". ]mZm)",
                "sec_num": null
            },
            {
                "text": "In the forward and backward rules given above, we say that (x/y) (resp. (x\\y)) is the primary constituent of the forward (resp. backward) rules and (y]1zl[2... ]mZm) is the secondary constituent of the rule. The notion of a distinguished child is defined as in the case of LIG, i.e., a category is the distinguished child of its parent if it corresponds to the primary constituent of the rule used. As before, the distinguished descendant is the reflexive, transitive closure of the distinguished child relation.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "In discussing CCG we use the notational conventions that the variables ] and c (when used with or without primes and subscripts) range over the forward and backward slashes and categories, respectively. We use x,y, z for meta-variables; a, fl for strings of directional categories (i.e., a string of the form ]1Cl]2.,. ]nOn from some n ~ 0); and A, B, C for atomic categories (i.e., members of VN).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "Derivations in a CCG, G = (VT, VN~ S,f, R), involve the use of the combinatory rules in R. Let ~ be defined as follows, where T1 and T2 are strings of categories G and terminal symbols.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "If ClC 2 ---+ C is an instance of a rule in R, then TlCT 2 ~ \"~1ClC2T2 . The set of rules R includes the following three rules.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "y (x\\y) ~ x (x/y) (y\\zl/z2) ---+ (y\\zl/z2) (x/y) (y\\zl) ~ (y\\zl)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "In each of these rules, the target of the category matched with x must be S. 7 Figure 7 shows a derivation of the string abbcabb.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 79,
                        "end": 87,
                        "text": "Figure 7",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "We find it convenient to represent categories in a minimally parenthesized form (i.e., without parentheses unless they are needed to override the left associativity of the slashes), where minimally parenthesized form is defined as follows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "7 Following Steedman (1985) , we allow certain very limited restrictions on the substitutions of variables in the combinatory rules. A discussion on the use of such restrictions is given in Vijay-Shanker and Weir (in press). However, we have not included this in the formal definition since it does not have a significant impact on the algorithm presented. CCG example derivation tree.",
                "cite_spans": [
                    {
                        "start": 12,
                        "end": 27,
                        "text": "Steedman (1985)",
                        "ref_id": "BIBREF11"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.3",
                "sec_num": null
            },
            {
                "text": "\u2022 A is the minimally parenthesized form of A where A C VN.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.4",
                "sec_num": null
            },
            {
                "text": "\u2022 If cl,...,c, are the minimally parenthesized forms of categories c~,..., c\"",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.4",
                "sec_num": null
            },
            {
                "text": "respectively, then (allcll2... Incn) is the minimally parenthesized form of (('-' (allc~)12'' \")l~c'). A category c is in minimally parenthesized form if c is the minimally parenthesized form of itself. ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 4.4",
                "sec_num": null
            },
            {
                "text": "Before showing how the general parsing scheme illustrated by the LIG recognition algorithm can be instantiated as a recognition algorithm for CCG, we show that CCG and LIG are very closely related. The details of the examination of the relationship between CCG and LIG may be found in Weir and Joshi (1988) and Weir (1988 (['c'11c112... ImCm) .",
                "cite_spans": [
                    {
                        "start": 285,
                        "end": 306,
                        "text": "Weir and Joshi (1988)",
                        "ref_id": "BIBREF19"
                    },
                    {
                        "start": 311,
                        "end": 321,
                        "text": "Weir (1988",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 322,
                        "end": 342,
                        "text": "(['c'11c112... ImCm)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "CCG and LIG",
                "sec_num": "4.1"
            },
            {
                "text": "We now show that, like the set of stack symbols of a LIG, the set of directional argument categories that we need to be concerned with is finite. (y]lZll2... ImZm) must take its arguments from args (G) (a finite set) and therefore the resulting useful category also shares this property. The above property makes it possible to adapt the LIG algorithm for CCG. Note that in the CKY-style CCG recognition we only need to record the derivations from useful categories. From Observation 4.1 it follows that the lexical category assignment, f, determines the number of \"stack\" symbols we need to be concerned with. Therefore, only one of the variables (x) in a combinatory rule is essential in the sense that the number of categories that it can usefully match is not bound by the grammar. Therefore, it would be possible to map each combinatory rule to an equivalent finite set of instances in which ground categories (from args (G)) were substituted for all variables other than x; i.e., y, zl}...Zm in the combinatory rule above. This would result in a grammar that was a slight notational variant of a LIG where the CCG variable x and the LIG notation .-perform similar roles. However, for the purpose of constructing a recognition algorithm it is both unnecessary and undesirable to expand the number of rules in this way. We adapt the LIG algorithm so that it, in effect, constructs appropriate instances of the combinatory rules as needed during the recognition process.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "CCG and LIG",
                "sec_num": "4.1"
            },
            {
                "text": "The first step in modifying the LIG algorithm is to define the constants MSL and MTL for the case of CCG. Let G --(VT, VN, S,f, R) be a CCG. These definitions follow immediately from the similarities between CCG combinatory rules and LIG productions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of CCG",
                "sec_num": "4.2"
            },
            {
                "text": "If we were to express a combinatory rule",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "(x/y) (yIlZl...ImZm) ~ (X]IZ1...]mZm)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "in terms of LIG production A (\"\")'1...\"/m) \"-'+ Ap (\"\"yp) As(o@) then we have the following correspondences:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 % with/y.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 \"~i with = ]izi for 1 < i < m, i.e., \"Y1 ''' \"Ym with IlZl ... ]mZm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 A = Ap.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 As (as) with yhz~... ImZm .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "Given such a direct correspondence between combinatory rules and LIG productions, we will define the following constants to be used in the the CCG algorithm with minimal explanation.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 MTL is the maximum arity of a lexical category. Thus, MTL = max { arity (c) ] c c f(a), a C VT }.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 MSL should be the maximum arity of a useful category that can match the secondary category of a rule. Note that a category matching (y]lZ1]2-.. ImZm) will have an arity that is the sum of m and the arity of the category matching y. Furthermore, note that since y is an argument of the primary category it must be bound to a member of args (G \u2022 Note that in the case of CCG, MCL need not be defined independently of MSL.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "\u2022 As before, we define TTC as TTC = max { MSL, MTL }.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "Since directional categories play the same role that stack symbols have in LIG, we revise the notions of length top ( ) and rest ( ) as follows. We say that the string of directional arguments categories ]lCl I2\"'\" InCh has a length n, i.e., len (IlCl 12. ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Observation 4.2",
                "sec_num": null
            },
            {
                "text": "We can define a k-terminator in essentially the same way as in the case for LIG. Note that a category shares its target category with all of its distinguished descendants. nil) ) assuming that j > 1.",
                "cite_spans": [
                    {
                        "start": 172,
                        "end": 176,
                        "text": "nil)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Terminators in CCG.",
                "sec_num": "4.2.1"
            },
            {
                "text": "However, it is possible that j = 0. In this case the category being represented is A, and the entry will be written as (IA~ c I (~ nil)) . In general, we use the non-terminatortype entry for recording a derivation from As when it has no terminator or when the terminator, say aflltCt (rewriting c~ as flllCl... is such that len (flltCt) ~__ TTC;",
                "cite_spans": [
                    {
                        "start": 119,
                        "end": 136,
                        "text": "(IA~ c I (~ nil))",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Terminators in CCG.",
                "sec_num": "4.2.1"
            },
            {
                "text": "i.e., when the category As does not satisfy the TC-property. ,/ce) O~c,, ((Ltc,), [t,d,] ( (Ap, /Cp) (tip, nil)) C P [i, dp] Asc~s = CpllCl ((As, top(c~s)) (rest(c~s),nil) ) C P [i + dp,d-d,] ((A e, ]1c,) (tie,nil)) E P [i,d] Rule 7.ps.C ( (Ap, /Cp) (flp, ( (Itct) , [t, dt] ) ) ) c Pfi, dp] As~s = Cp[lCl ((As,top(c~s)l (rest(c~s) ,nil)) C P[i +dp~d-dp] ((Ap, llCl ) (tip, ((ItCt) , [t, dt] ) ) ) C P [i,d] When m > 2 and tpp ~ nil Rule 8.ps.C tpp = (lltctl, [t~dt] ) (IAp, /Cp> (tip, tpp) ) E PIi, dp] As~s = CpllCl ... ImCm ( IA~, top (c~s) l (rest (c~s) , nil)) E P [i + dp, d -dp] ( (Ap, , [i, dp] ) ) ) C P [i,d] ((As, top(c~s) ) (rest(c~s),nil) ) c P[i + dp,d -dp] ((ap, Ii,  dp]) ) ) C P [i,d] Proposition 4.1 The CCG recognition algorithm can be seen to establish the following.",
                "cite_spans": [
                    {
                        "start": 117,
                        "end": 124,
                        "text": "[i, dp]",
                        "ref_id": null
                    },
                    {
                        "start": 178,
                        "end": 191,
                        "text": "[i + dp,d-d,]",
                        "ref_id": null
                    },
                    {
                        "start": 220,
                        "end": 225,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 238,
                        "end": 249,
                        "text": "( (Ap, /Cp)",
                        "ref_id": null
                    },
                    {
                        "start": 250,
                        "end": 264,
                        "text": "(flp, ( (Itct)",
                        "ref_id": null
                    },
                    {
                        "start": 267,
                        "end": 274,
                        "text": "[t, dt]",
                        "ref_id": null
                    },
                    {
                        "start": 306,
                        "end": 331,
                        "text": "((As,top(c~s)l (rest(c~s)",
                        "ref_id": null
                    },
                    {
                        "start": 355,
                        "end": 367,
                        "text": "((Ap, llCl )",
                        "ref_id": null
                    },
                    {
                        "start": 368,
                        "end": 381,
                        "text": "(tip, ((ItCt)",
                        "ref_id": null
                    },
                    {
                        "start": 384,
                        "end": 391,
                        "text": "[t, dt]",
                        "ref_id": null
                    },
                    {
                        "start": 402,
                        "end": 407,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 460,
                        "end": 466,
                        "text": "[t~dt]",
                        "ref_id": null
                    },
                    {
                        "start": 469,
                        "end": 490,
                        "text": "(IAp, /Cp> (tip, tpp)",
                        "ref_id": null
                    },
                    {
                        "start": 527,
                        "end": 557,
                        "text": "( IA~, top (c~s) l (rest (c~s)",
                        "ref_id": null
                    },
                    {
                        "start": 586,
                        "end": 592,
                        "text": "( (Ap,",
                        "ref_id": null
                    },
                    {
                        "start": 613,
                        "end": 618,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 619,
                        "end": 633,
                        "text": "((As, top(c~s)",
                        "ref_id": null
                    },
                    {
                        "start": 672,
                        "end": 677,
                        "text": "((ap,",
                        "ref_id": null
                    },
                    {
                        "start": 678,
                        "end": 681,
                        "text": "Ii,",
                        "ref_id": null
                    },
                    {
                        "start": 682,
                        "end": 682,
                        "text": "",
                        "ref_id": null
                    },
                    {
                        "start": 696,
                        "end": 701,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 61,
                        "end": 88,
                        "text": ",/ce) O~c,, ((Ltc,), [t,d,]",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Terminators in CCG.",
                "sec_num": "4.2.1"
            },
            {
                "text": "\u2022 (lAp, Ic~ (t3, (lltctl, [t~ dt] \u2022 ((Ap, top(cO~, (rest(cO, nil,) ) E P [i,d] if and only if Ac~ ~ ai...ai+d-1",
                "cite_spans": [
                    {
                        "start": 2,
                        "end": 7,
                        "text": "(lAp,",
                        "ref_id": null
                    },
                    {
                        "start": 8,
                        "end": 16,
                        "text": "Ic~ (t3,",
                        "ref_id": null
                    },
                    {
                        "start": 17,
                        "end": 25,
                        "text": "(lltctl,",
                        "ref_id": null
                    },
                    {
                        "start": 26,
                        "end": 33,
                        "text": "[t~ dt]",
                        "ref_id": null
                    },
                    {
                        "start": 36,
                        "end": 66,
                        "text": "((Ap, top(cO~, (rest(cO, nil,)",
                        "ref_id": null
                    },
                    {
                        "start": 73,
                        "end": 78,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ae",
                "sec_num": null
            },
            {
                "text": "and either Ac~ has no terminator or its terminator, say Ac~ t is such that len (c~') < TTC.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "((Ae",
                "sec_num": null
            },
            {
                "text": "We begin this section by first considering how to extend our algorithm for LIG to handle unary productions. This will be needed to show we can instantiate our scheme to give a recognition algorithm for TAG.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "TAG Recognition",
                "sec_num": "5."
            },
            {
                "text": "We will now show how the LIG algorithm given earlier can be extended to consider unary productions of the form A (.. ~1... \"Ym) -'-9 Ap (.. 3'p) as well as e productions of the form: A (c~) --+ e. However, we will now assume that m G 2 in productions of the form A (.. 2/1 ... q/m) --+ T1ap ('\" q/p) T2. Thus, henceforth MCL < 2. Note that this refers to both unary and binary productions. This additional restriction does not change the generative power. We have introduced these restrictions in order to reduce the number of cases we have to consider and also because we can restrict our attention to the productions that are used in the TAG to LIG construction.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Consider the processing of a binary production A (.. 2/1 ... 2/m) ---+ Ap (.. \"yp) As (as).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Since CKY-style parsers work bottom-up, we check to see if the primary and secondary categories derive adjacent strings (say ai...ai+dp-1 and ai+dp...ai+dp+&, respectively) and then we store an encoding for the new object that results from the combination. The processing of unary productions is similar except that we do not have to consider a secondary constituent. The rules that express the processing of such productions will be very similar to those for the binary productions. ((A, top (G) ) (rest (&),nil)) E P [i,d] In addition, with the introduction of e productions, we have to consider derivations of strings of length d --0. We shall assume that if A (c~) ~ e then an encoding of A (~) will be stored in P [i, 0] (for all i). We must also consider the possibility that the primary constituent or the secondary constituent derive the empty string, i.e., dp = 0 or ds = 0. Processing of such cases becomes similar to that of unary productions. To indicate the additional processing required due to the introduction of unary productions and the possibility of the derivation of the empty string, let us consider Rule 8.ps.L. \"Use Rule 8.ps.U' can be paraphrased as follows. If we allow ~ productions it is possible that ds ---d-dp --0. Consider the case where we have As (as) ~ c. That is, we expect the entry e2 to be present in P [i + d, 0] [0, 0] . This means that the resulting entry e3 must be added to P [i, d] ",
                "cite_spans": [
                    {
                        "start": 519,
                        "end": 524,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 719,
                        "end": 725,
                        "text": "[i, 0]",
                        "ref_id": null
                    },
                    {
                        "start": 1342,
                        "end": 1359,
                        "text": "[i + d, 0] [0, 0]",
                        "ref_id": null
                    },
                    {
                        "start": 1420,
                        "end": 1426,
                        "text": "[i, d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "[i, d",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "] since we now have dp = d. Note that the addition of e3 = ((A,\"/m) (\"yl...\"Yrn--l~ZZ~p~p~) ) (that encodes the derivation from A (fl'yl ... %) for some fl) can result in more entries being added to the same array element P [i, d] [i, d] (for instance, when we have the production B (--2/~ ... 2/~) --+ A (-. \"Ym)). This is similar to the prediction phase in Earley's algorithm and the state construction in LR parsing. Based on this analogy, we will define our notion of closure. Closure (e,i,d,t, dt) will add entries to PIi, d] It, dr] or PIi, d] Ii, d] that result from the inclusion of the entry P Ii, d] It, dt] by considering unary productions (or binary productions when the primary or secondary constituent derives the empty string). Before we define Closure () we note that for each occurrence in the algorithm of \"use Rule X\" is replaced by \"use closure of Rule X.\" For example, \"Use closure of Rule 8.ps.U' stands for If we have the production A (\"~1. . . ?m) ~ Ap (.. %) As (C~s) where m ~ 2, el = (IAp, ~pl (flp,At~',/t) ) belongs to PIi, d] It, dt] and e2 = ( IAs~ top (C~s) l (rest (C~s)~ nil) ) belongs to P Ii + dp~ d -dp] IO~ 0] and e3 ~-(/a~ '~m/(~/1-.. \"Ym-l~ap~ \"Yp)) does not belong to P [i,d] Ii, dp] then add e3 to PIi, d] Ii~dp] and then invoke Closure (e3,i~d~i~dp).",
                "cite_spans": [
                    {
                        "start": 68,
                        "end": 91,
                        "text": "(\"yl...\"Yrn--l~ZZ~p~p~)",
                        "ref_id": null
                    },
                    {
                        "start": 224,
                        "end": 230,
                        "text": "[i, d]",
                        "ref_id": null
                    },
                    {
                        "start": 231,
                        "end": 237,
                        "text": "[i, d]",
                        "ref_id": null
                    },
                    {
                        "start": 489,
                        "end": 502,
                        "text": "(e,i,d,t, dt)",
                        "ref_id": null
                    },
                    {
                        "start": 1011,
                        "end": 1034,
                        "text": "(IAp, ~pl (flp,At~',/t)",
                        "ref_id": null
                    },
                    {
                        "start": 1211,
                        "end": 1216,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Closure is defined as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Closure ( e, il, dl , t, dr) begin use closure of Rule 2.ps.L, 6.ps.L, 7.ps.L, 8.ps.L, 9.ps.L, 10.ps.L with d = dp and the entry e as the primary constituent in the antecedent. use closure of Rule 2.sp.L, 6.sp.L, 7.sp.L, 8.sp.L, 9.sp.L, 10.sp.L with ds --d and the entry e as the secondary constituent in the antecedent. use closure of Rule 2.u. L, 6.u.L, 7.u.L, 8.u.L, 9.u.L, 10.u.L with d = dp and the entry e as the primary constituent in the antecedent. end.",
                "cite_spans": [
                    {
                        "start": 8,
                        "end": 28,
                        "text": "( e, il, dl , t, dr)",
                        "ref_id": null
                    },
                    {
                        "start": 346,
                        "end": 383,
                        "text": "L, 6.u.L, 7.u.L, 8.u.L, 9.u.L, 10.u.L",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Note Rule 3 does not apply since we have to assume MCL _< 2 (hence any terminator is a 2-terminator and the length of the middle in a terminator-type entry is always one). We have not included Rule 4 and Rule 5 while computing the closure. These correspond directly to the completor step in Earley's algorithm and to the popping of stack elements and hence are not considered a part of the closure. They have to be applied later in the control structure.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "We will now consider the effect of including unary rules on the control structure of the algorithm. Let//il, dl/~/i2, d2//G//i3, d3/~ lid, dd//if and only if (1) (il, dl/ < (i3, d3/ or (2) /il~ dl/ ---/i3~ d3/and/i2~ d2/ < (i4~ dd/. The simplicity of the loop structure in the algorithms seen thus far stems from the fact that for any parsing rule if the entry in the consequent is to be added to P Ii3, d3] Iid~ dd] based on the existence of an antecedent entry in P Iil, dl] I/'2, d2], then Ilil, dll, lid, d211 ~ Ili3, d31~ lid, dd}l. This no longer holds when we consider Rule 5.u.L or Rule 5.ps.L when the secondary constituent derives the empty string. Consider the following derivation (and the presence of the productions assumed) for a sufficiently long fl: a (flo~) ~ a 1 (fl\"~l) ~ A2 (fl~l~Y2) ~ A3 (fl'y) ~ ai... ai+d-1",
                "cite_spans": [
                    {
                        "start": 493,
                        "end": 498,
                        "text": "Ilil,",
                        "ref_id": null
                    },
                    {
                        "start": 499,
                        "end": 503,
                        "text": "dll,",
                        "ref_id": null
                    },
                    {
                        "start": 504,
                        "end": 508,
                        "text": "lid,",
                        "ref_id": null
                    },
                    {
                        "start": 509,
                        "end": 521,
                        "text": "d211 ~ Ili3,",
                        "ref_id": null
                    },
                    {
                        "start": 522,
                        "end": 531,
                        "text": "d31~ lid,",
                        "ref_id": null
                    },
                    {
                        "start": 532,
                        "end": 537,
                        "text": "dd}l.",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Consider the addition of an entry e3 to P [i,d] It, dr] (for some It, dtl) to record the derivation from A3 (fl'y). Closure (e3~ i, d, t, dr) is invoked, resulting in the addition of e2 (corresponding to A2 (fl'Y13'2)) to P [i, d] Ii, d] . From Rule 5.u.L and the presence of entry e2 and e3 we would add el (corresponding to al (fl3/1) to P Ii, d] It, dt]). This could result in the need to add more entries to Control structure with unary productions.",
                "cite_spans": [
                    {
                        "start": 42,
                        "end": 55,
                        "text": "[i,d] It, dr]",
                        "ref_id": null
                    },
                    {
                        "start": 224,
                        "end": 237,
                        "text": "[i, d] Ii, d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 124,
                        "end": 141,
                        "text": "(e3~ i, d, t, dr)",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "an antecedent entry in P",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "[i,d] It, dr] ((t, dt) < (i,d))",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "causes an entry to be added to",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "P [i, d] [i, d",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "], which, acting as an antecedent entry, causes a new entry to be added to",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "P[i,d] It, dr].",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "A simple strategy to take care of this situation would be to add another loop within the t loop (as shown in the partial control structure given in Figure 8 ) that is repeated until no new entries are added to P",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 148,
                        "end": 156,
                        "text": "Figure 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "[i, d] It, dt].",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "It is straightforward to prove the correctness of the algorithm with this additional loop and also that the asymptotic complexity remains the same. The latter is the case because only a bounded number of entries can belong to P [i,d] It, dr] for any fixed value of i, d, t, dr, and hence the repeat loop can be iterated only a bounded number of times (as determined by the grammar). In the partially specified control structure given in Figure 8 , we have not considered the sp rules. Also we only consider the changes that need to be made to Algorithm 1; the changes to Algorithm 2 can be made in a similar fashion. Finally, for purposes of abbreviation, we have grouped Rules 2.ps.L, 6.ps.L, 9.ps.L, and 10.ps.L together and called it the Rule set I, and Rules 3.ps.L, 4.ps.L, 7.ps.L, and 8.ps.L the Rule set II.",
                "cite_spans": [
                    {
                        "start": 228,
                        "end": 241,
                        "text": "[i,d] It, dr]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 437,
                        "end": 445,
                        "text": "Figure 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "The repeat loop shown in Figure 8 is not needed in some situations. Consider the derivation and the sequence of addition of entries, e3~ e2~ el, as discussed above. Viewing this derivation as a bottom-up recognizer would, we have a \"prediction\" from entry e3 followed by a \"completion\" that results in the entry el. In this case the two entries both encode objects with the same stack length. We generalize this situation and call such derivations auxiliary derivations (named after auxiliary trees in TAG). a (fl\"Yl) ~ TIA1 (fl~/l\"/2)T2 ~ TlUAt (fl'Tt)wT2 ~ UlUAt (fl\"Yt)WWl",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 25,
                        "end": 33,
                        "text": "Figure 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "where At (fl'Tt) is the 2-terminator of A1 (fl\"/1\"/2). We will say that this auxiliary derivation spans at least one terminal if len (UlUWWl) _> 1. Notice that if for a particular grammar every auxiliary derivation spans at least one terminal, then the extra repeat loop added becomes unnecessary. This is because now, with this assumption, for every parsing rule if the entry in the consequent is to be added to P [/3~ d3] [i4~ dd] based on the existence of an antecedent entry in P[/1, dl] [12~ d2] then ((il, dl), (12~ d2)) -< ((i3, d3), (i4~ dd)).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "We end this section by noting that in the case of a lexicalized TAG, we can verify that every auxiliary derivation spans at least one terminal, and hence in the TAG algorithm we do not have to include this additional repeat loop.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Handling Unary Productions and Epsilon Productions",
                "sec_num": "5.1"
            },
            {
                "text": "Tree Adjoining Grammars (TAG) is a tree generating formalism introduced by Joshi, Levy, and Takahashi (1975) . A TAG is defined by a finite set of trees composed by means of the operation of tree adjunction.",
                "cite_spans": [
                    {
                        "start": 75,
                        "end": 108,
                        "text": "Joshi, Levy, and Takahashi (1975)",
                        "ref_id": "BIBREF4"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Tree Adjoining Grammars",
                "sec_num": "5.2"
            },
            {
                "text": "A TAG, G, is denoted by (VN, VT~ 57 Iv A) where VN is a finite set of nonterminals symbols, VT is a finite set of terminal symbols, S E VN is the start symbol, I is a finite set of initial trees, A is a finite set of auxiliary trees.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.1",
                "sec_num": null
            },
            {
                "text": "An initial tree is a tree with root labeled by S and internal nodes and leaf nodes labeled by nonterminal and terminal symbols, respectively. An auxiliary tree is a tree that has a leaf node (the foot node) that is labeled by the same nonterminal that labels the root node. The remaining leaf nodes are labeled by terminals and all internal nodes labeled by nonterminals. The path from the root node to the foot node of an auxiliary tree is called the spine of the auxiliary tree. An elementary tree is either an initial tree or an auxiliary tree. We will use c~ to refer to an initial tree, and fl to refer to an auxiliary tree. \"y may be used to refer to either an elementary tree or a tree that is derived from an elementary tree.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.1",
                "sec_num": null
            },
            {
                "text": "We will call a node in an elementary tree an elementary node. We can give a unique name to each elementary node by using an elementary node address. An elementary node address is a pair composed of the name of the elementary tree to which the node belongs and the address of the node within that tree. We will assume the standard addressing scheme where the root node has an address c. If a node addressed # has k children then the k children (in left to right order) have addresses # \u2022 1,..., # \u2022 k. Thus, if dV\" is the set of natural numbers then # E W'*. In this section we will use # to refer to addresses and ~/to refer to elementary node addresses. In general, we can write ~ = IV, #/ where 3` is an elementary tree and # E Domain (3'). We will use Domain (3') for the set of addresses of the nodes in %",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.1",
                "sec_num": null
            },
            {
                "text": "Let 3` be a tree with internal node labeled by a nonterminal A. Let fl be an auxiliary tree with root and foot node labeled by the same nonterminal A. The tree, 3`~, that results from the adjunction of fl at the node in 3` labeled A (as shown in Figure 9 ) is formed by removing the subtree of 3` rooted at this node, inserting fl in its place, and substituting it at the foot node of ft.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 246,
                        "end": 254,
                        "text": "Figure 9",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "Each elementary node is associated with a selective adjoining (SA) constraint that determines the set of auxiliary trees that can be adjoined at that node. In addition, when adjunction is mandatory at a node it is said to have an obligatory adjoining (OA) constraint. Figure 9 shows how constraints are associated with nodes in trees derived from adjunctions. Whether fl can be adjoined at the node (labeled by A) in 3` is determined by c, the SA constraint of the node. In 3`r the nodes contributed by fl The operation of adjoining.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 268,
                        "end": 276,
                        "text": "Figure 9",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "have the same constraints as those associated with the corresponding nodes in ft. The remaining nodes in 7' have the constraints of the corresponding nodes in 3`.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "Given/* E Domain (3`), by LABEL(% #/we refer to the label of the node addressed /* in 7. If the tree in question is clear from context, we will simply use LABELI#/. Similarly, we will use SA(%/*) (or SA(#)) and OA(% #) (or OA(/*)) to refer to the SA and OA constraints of a node addressed /* in a tree 3`. Finally, we will use ft (/3) to refer to the address of the foot node of an auxiliary tree/3.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "To be precise, we define the adjunction of/3 at a node in 7 with address /* as follows. This operation is defined when/3 is included in the SA constraints of node addressed # in 3`. If the operation is defined, we will use ADJ (3`, #,/3) to refer to the tree that results. Let 3'' = AD3 (%/*,/3). Then the nodes in 3'' and their labels and adjoining constraints are defined as follows. In general, if # is the address of a node in \"~ then by (% #) we refer to the elementary node address of the node that contributes to its presence, and hence its label and constraints.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "The tree language, T(G), generated by a TAG, G, is the set of trees derived starting from an initial tree such that no node in the resulting tree has an OA constraint. The (string) language, L(G), generated by a TAG, G, is the set of strings that appear on the frontier of trees in T(G).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "Example 5.1 Figure 10 gives a TAG, G, which generates the language {wcw I w E {a, b}+}. The constraints associated with the root and foot of fl specify that no auxiliary trees can be adjoined at these nodes. This is indicated in Figure 10 by associating the empty set, G with these nodes. An example derivation of the strings aca and abcab is shown in Figure 11 .",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 12,
                        "end": 21,
                        "text": "Figure 10",
                        "ref_id": "FIGREF11"
                    },
                    {
                        "start": 229,
                        "end": 238,
                        "text": "Figure 10",
                        "ref_id": "FIGREF11"
                    },
                    {
                        "start": 352,
                        "end": 361,
                        "text": "Figure 11",
                        "ref_id": "FIGREF11"
                    }
                ],
                "eq_spans": [],
                "section": "Definition 5.2",
                "sec_num": null
            },
            {
                "text": "In this section, we examine bottom-up recognition of a TAG. In doing so, we construct a LIG that simulates the derivations of the TAG. Based on this construction, we derive a recognizer for TAG from the algorithms given earlier.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "TAG and LIG",
                "sec_num": "5.3"
            },
            {
                "text": "Consider bottom-up TAG recognition. Having recognized the substring dominated by an elementary node there are two possible actions: (1) move up the tree by combining this node with its siblings; or (2) consider adjunction at that node. In bottom-up recognition, the second action (i.e., adjunction) must be considered before the first. Therefore, there are two phases involved in the consideration of each node. On entering the bottom phase of a node, having just combined the derivations of its children, we predict an adjunction. On entering the top phase, having just finished adjunction at that node, we must now combine with any siblings in order to move up the tree. Note that in the bottom phase we may also predict that there is no adjunction at the node (if there is no OA constraint on that node) and hence move to its top phase directly. Figure 12 shows why, because of the nature of the adjoining operation, TAG can be seen to involve stacking. Suppose, during recognition, the bottom phase of a node, 7], ",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 849,
                        "end": 858,
                        "text": "Figure 12",
                        "ref_id": "FIGREF11"
                    }
                ],
                "eq_spans": [],
                "section": "TAG and LIG",
                "sec_num": "5.3"
            },
            {
                "text": "Stacking in a TAG.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "has been reached. When adjunction by the auxiliary tree fl is predicted, control shifts to the bottom phase of fl's foot node. As we move up the spine of fl it is necessary to remember that fl was adjoined at 7. On reaching the top phase of fl's root we must return to (the top phase of) 7. Therefore, the adjunction point, ~7, must be propagated up the spine of ft. In general, we may need to propagate a stack of adjunction points as we move up the spine as shown in Figure 12 where 3'2 is obtained by adjoining 131 at a node ~11 on the spine of ft. From this figure, it can be seen that the information about the adjunction points (that must be propagated along the spine of an auxiliary tree) follows the stack (last-in first-out) discipline. Notice also that only the nodes on the spine participate in the propagation of adjunction points.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 469,
                        "end": 478,
                        "text": "Figure 12",
                        "ref_id": "FIGREF11"
                    }
                ],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "Consider how a LIG that simulates this process can be constructed. The details of the equivalence between LIG and TAG can be found in Vijay-Shanker (1987) . In the LIG, we use two nonterminals, t and b to capture the differences between the top and bottom phases associated with a node. The stack holds an appropriate sequence of adjunction points in the form of elementary node addresses. The top of the stack is the elementary node address of the node that is currently being visited (thus all objects have at least one element on the stack). Nodes that are not on the spine, or belong to an initial tree, do not participate in the propagation of adjunction points. Therefore, the objects for such nodes will have stacks that contain only their elementary node address.",
                "cite_spans": [
                    {
                        "start": 134,
                        "end": 154,
                        "text": "Vijay-Shanker (1987)",
                        "ref_id": "BIBREF13"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "The set of LIG productions is determined as follows. We assume that internal elementary nodes have either a single child labeled by a terminal symbol (or ~), or exactly two children labeled by nonterminals. In this discussion below, we will use ~] for a node and its elementary node address interchangeably.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "1. If ?7 is a node that is labeled e where ~ c V T U{~} then we will include t 07) ---+ c.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "2. If ?Tp and qs are the children of a node ?7 such that the left sibling ~/p (and hence ?7) is on the spine then the following holds: (1) the object corresponding to ~/p can have an unboundedly large stack, whereas the object for ?7s will have a stack of size one;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "(2) the top of the stack in these objects will be ?Tp and ~Ts;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "(3) combination of these two sibling nodes is possible only after the top parts of these nodes are reached; (4) the stack in the object for ~]p must be propagated to object for 77, except that the top symbol ?7p is replaced by ?7; (5) when the two sibling nodes are combined we reach the bottom part of ?7. Hence, we include the production b (.. ?7) ---+ t (.. ?Tp) t 07s).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "3. If ?7p, ~]s are children of ~ as in the previous case except that ?7p is the right sibling and is on the spine, then we include the production b ('\" n) -~ t(ns) t (..'qp).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "4. If ?Tp, qs, and 77 are as before except that neither sibling is on the spine of an auxiliary tree then we include the production b (.. ?/) ~ t (.-?7p) t 07s).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "5. If ?7p is the only child of 77 we have b (.. ?7) --+ t (--77p ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "6. If ?7 is a node where fl can be adjoined and we are at the bottom of ~7, then, by predicting adjunction by fl, control moves to the bottom part of 771 (the foot node of fl). This is illustrated in Figure 13 . In this case we add the production b (.. 77771) --+ b (.. 77). When there is no OA constraint at 77 then we can predict that no adjunction takes place. This is captured with the production t (.. 7/) --+ b (--?7).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 200,
                        "end": 209,
                        "text": "Figure 13",
                        "ref_id": "FIGREF11"
                    }
                ],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "7. Suppose we have reached the top part of the root node, 772, of the auxiliary tree ft. The corresponding object has the nonterminal t with 772 on top of the stack and the node at which fl was adjoined is immediately below 772. Having reached the top of the root node of fl we must return to the top of the node where fl was adjoined. This is accomplished with the production t (..) ---+ t (.. 72) (see Figure 13 ). Figure 13 captures the essence of the connection between TAG and LIG--in particular the way the adjoining operation in TAG can be simulated in LIG. This figure is also useful in order to understand the notion of terminators. As in the case of CCG, the construction of the LIG equivalent of the given grammar is unnecessary. However, as in the case of CCG, this discussion of the connection between TAG and LIG can be used to motivate the choices we make in the form of entries in TAG parser as well as the rules in the algorithm.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 404,
                        "end": 413,
                        "text": "Figure 13",
                        "ref_id": "FIGREF11"
                    },
                    {
                        "start": 417,
                        "end": 426,
                        "text": "Figure 13",
                        "ref_id": "FIGREF11"
                    }
                ],
                "eq_spans": [],
                "section": "Figure 12",
                "sec_num": null
            },
            {
                "text": "We now give a CKY-style recognition algorithm for TAG. But first we shall consider the LIG constructed from a given TAG as described in Section 5.3. Given this LIG grammar, consider the objects derived and the form of entries that will be used by the LIG algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "\u2022 If ~ is an elementary node address of a node on the spine of an auxiliary tree, say fl, then any object that has ~ as the top symbol of its stack must be of the form A (~h ... 7]k~]t~) where k > 0, A C {t, b}, and/It is the elementary node address of a node where fl can be adjoined. Furthermore, in any derivation, the terminator of A (~t77) will be b (~rlt).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "\u2022 For this LIG, MSL = MTL = TTC = 1 and MCL = 2. Hence it follows that any terminator is a 2-terminator. From the discussion above, an object A (9~) (where A C {t, b} and len (~) > 0) has a terminator if and only if is an elementary node address of a node on the spine of an auxiliary tree.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "\u2022 Consider the forms of entries for a LIG in this form. First, the length of the middle in a terminator-type entry will be one always, since any terminator is a 2-terminator. Note that the terminator of A (9~t~) will be b (~t). Thus, a terminator type entry in a parsing array entry, say P [i, d] will have the form ({A,~)O]t, ({b,~lt}, [t, dt] ))) where A c {t,b} and It, dr} < li, d}. Note that {b, ~Tt) in the terminator-pointer is redundant.",
                "cite_spans": [
                    {
                        "start": 290,
                        "end": 296,
                        "text": "[i, d]",
                        "ref_id": null
                    },
                    {
                        "start": 327,
                        "end": 344,
                        "text": "({b,~lt}, [t, dt]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "\u2022 From the discussion above, a non-terminator-type entry wilt be used to record derivations from A (7) where A E {t, b} and r/is the elementary node address of a node that belongs to an initial tree or of a node that is not on the spine of an auxiliary tree. To record this object the entry ((A, 71, nil) would have been used.",
                "cite_spans": [
                    {
                        "start": 291,
                        "end": 304,
                        "text": "((A, 71, nil)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "From the above discussion it makes sense that terminator-type entries in the TAG parser have the form ((A, T]/ (7t, t, dt)) where A E {t,b}, 7 is an elementary node address of a node on the spine of an auxiliary tree, say fl, and /'It is the elementary node address of a node where fl can be adjoined in. A non-terminator-type entry has the form ((A, 7) , nil) where A E {t, b}, and 7 is an elementary node address of a node that is not on the spine of an auxiliary tree. Finally, consider an auxiliary derivation in the LIG obtained from a TAG as described in Section 5.3. Recall that an auxiliary derivation has the form A (~71) ~ TIA1 (~')'172) T2",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 346,
                        "end": 353,
                        "text": "((A, 7)",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "T~uAt (9~\"yt) wT 2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "In this case we would have: \u2022 At = b, and",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "\u2022 \"72 is the root of an auxiliary tree that can be adjoined at the node whose elementary node address is given by ~?t.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "Since every auxiliary tree in a lexicalized TAG has at least one terminal node in its frontier, every auxiliary derivation spans at least one terminal in the LIG we have constructed.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition of TAG",
                "sec_num": "5.4"
            },
            {
                "text": "We begin with a description of the cases involved in TAG recognition algorithm.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Recognition Algorithm",
                "sec_num": "5.5"
            },
            {
                "text": "During the recognition phase, on reaching the bottom part of a node 7, we predict adjunction by each auxiliary tree, fl that can be adjoined at 7 as determined by its SA constraints. As given in Case 6 of the construction in Section 5.3, this prediction is captured with the LIG production b (.. ~/~]1) -~ b (.. 7) where 71 is the foot node of the auxiliary tree, ft. Depending on whether 7 is on the spine of an auxiliary tree or not, we have the following counterparts of Rule 8.u.L and Rule 10.u.L: ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "((t,%),nil) E P[i,d] ((b,r/) ,nil) E P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Completing an adjunction: Corresponding to Case 7 of the construction and depending on whether the node of adjunction is on the spine of an auxiliary tree, we have the following counterparts of Rule 4.u.L, Rule 5.u.L.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Rule 4.u.T ((t,~lp) (zlt, t, dt)) E P [i,d] ~?t is not on the spine of any auxiliary tree ((b,z] ",
                "cite_spans": [
                    {
                        "start": 38,
                        "end": 43,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 90,
                        "end": 96,
                        "text": "((b,z]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "t),nil) E Pit, dr] ((t,,t) ,nil) E P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Rule 5.u.T ((t,\u2022e) (,t,t, dt)) E P [i,d] 7/t is on the spine of an auxiliary tree",
                "cite_spans": [
                    {
                        "start": 35,
                        "end": 40,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "((b,r]t) (l']r, Gdr) ) E P[t, dt] ((t,~]t) (~lr, r, dr)) E P[i,d]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "From the nature of entries being created it will follow that if ~]p = (fl, e), for some auxiliary tree fl, then fl is adjoinable at z]t. Similarly, if ~t ~-(fl', #) for some auxiliary tree fl', then fl' is adjoinable at/'Jr.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Scanning a terminal symbol: If z/is a node labeled by a terminal matching the i th input symbol, ai, then we have (corresponding to Rule 1.L):",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Rule 1.T LABEL(7])=ai l < i < n ((t, r/), nil) E P[i, 1]",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Scanning empty string: If ~ is a node labeled by e, then we have (corresponding to Rule lx.L):",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "Rule 1.e.T LABEL(z]) = e (It, n) ,nil) E P [i,0] This concludes our discussion of the parsing rules for TAG. With the correspondences with the LIG parsing rules given (via the numbering of rules), these rules may be placed in the control structure as suggested in Section 5.1. As noted earlier, in the case of a lexicalized TAG, since every auxiliary derivation spans at least one terminal we do not require the repeat loop discussed in Section 5.1.",
                "cite_spans": [
                    {
                        "start": 43,
                        "end": 48,
                        "text": "[i,0]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicting adjunction:",
                "sec_num": null
            },
            {
                "text": "In this paper we have presented a general scheme for parsing a set of grammar formalisms whose derivation process is controlled by (explicit or implicit) stacking machinery. We have shown how this scheme can be instantiated to give polynomial time algorithms for LIG, CCG, and TAG. In the case of CCG, this provides the only polynomial parsing algorithm (apart from a slight variant of this scheme given in Vijay-Shanker and Weir (1990)) we are aware of.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "The main contribution of this paper is the general recognition scheme and definitions of some notions (e.g., terminators, data structures sharing of stacks) crucial to this scheme. We believe that these ideas can be suitably adapted in order to produce parsing schemes based on other CFG parsing algorithms (such as Earley's algorithm). For instance, the definition of terminator given here was tailored for pure bottom-up parsing. In the case of Earley's algorithm, a bottom-up parser with top-down prediction, an additional notion of terminator for the top-down prediction component can be obtained in a straightforward manner.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "We have also introduced a new method of representing derivations in a TAG, one that we believe is appropriate in capturing the stacking that occurs during a TAG derivation. The derivations themselves represented can be in another TAG that we call the derivation grammar (see Vijay-Shanker and Weir (1993)).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "We have not discussed the extraction of parses after the recognition is complete because of space considerations. However, an algorithm to extract the parses and build a shared forest representation of all parses for CCG was proposed in Vijay-Shanker and Weir (1990) . This scheme was based on the approach we have taken in our general scheme. The method of extracting parses and representing them using a shared forest given in Vijay-Shanker and Weir (1990) can be generalized in a straightforward manner to be compatible with the generalized recognition scheme given here. such that At (fltTt) does not meet the TC-property. However, Ap (ol'/l'/p) satisfies the TC-property and furthermore At (o~'/t) is the 2-terminator of Ap (c~'/l'/p). From Observation 2.1, we can also infer the existence of the following derivation.",
                "cite_spans": [
                    {
                        "start": 255,
                        "end": 266,
                        "text": "Weir (1990)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 447,
                        "end": 458,
                        "text": "Weir (1990)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "Ap (flt'/l'/p) ~ ai. . .at-lAt (flt'/t) At (fit'~t) has no terminator then neither does A (fit'/I)). Since At (fit'~t) does not satisfy the TC-property (i.e., it does not have a terminator with stack length greater than or equal to TTC), A (fit'~l) does not satisfy the TC-property either.",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 39,
                        "text": "(flt'/l'/p) ~ ai. . .at-lAt (flt'/t)",
                        "ref_id": null
                    },
                    {
                        "start": 40,
                        "end": 51,
                        "text": "At (fit'~t)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "Thus we have shown the existence of the required derivation.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "Let m = 1. Therefore the production may be written as A (.. \"/1) --+ Ap (.. %) As (oes). This time we will take Rule 6.ps.L as a representative. Hence, we can assume that the entry added to P [i, d] has the form ((A,'/1)(tip, nil)). Since (i, dp) < (i,d) , and (i + dp, d -ds) < (i, d), the inductive hypothesis applies to the two entries in the antecedent. Thus, we have the following derivations:",
                "cite_spans": [
                    {
                        "start": 249,
                        "end": 254,
                        "text": "(i,d)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "Ap (gp'/,) a, ai+ -i Note that any terminator of Ap (tip'~p) is also the terminator of A (tip'~l) (and if Ap (tip'~p) has no terminator then neither has A (flpVl)). Since Ap (tip'~p) does not meet the TC-property in this derivation (from inductive hypothesis), neither does A (tip'~p). Thus we have shown the existence of the required derivation.",
                "cite_spans": [
                    {
                        "start": 98,
                        "end": 117,
                        "text": "(and if Ap (tip'~p)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "Let m > 2. We will consider the application of Rule 10.ps.L as a representative. Again, applying the inductive hypothesis we have the following derivations: Since m > 2, Ap (tip'/p) is the m-terminator of A (flp\"Yl... \"Ym) in the above derivation. Since fen (flp'yp) >_ TTC, we have shown the existence of the required derivation and that A (tip71...'Ym) satisfies the TC-property.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "In a similar manner we can consider other rules (including those that assume a production of the form A (.. \"Yl'.. \"Ym) ---+ As (c~s) Ap (.. 7p)) as well.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6."
            },
            {
                "text": "We will now show the completeness of Algorithm 1. This time we use induction on the number of steps in a derivation. Suppose A (fl) ~ ai...ai+d-1; we have to show that there is a corresponding entry (as specified in Theorem A.1) in P [i, d] .",
                "cite_spans": [
                    {
                        "start": 234,
                        "end": 240,
                        "text": "[i, d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "The base case corresponds to l = 1. From the form of the productions being considered we can assume that d = 1 and that there exists a production A (~) ~ ai.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Rule 1 would apply and thus we have the required entry.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Let A (fl) ~ ai... ai+d-i where l >__ 1. The first production used in this derivation must have the form A (.. \"rl . . . \"Ym)--+ Ap (\" \")'p) As (C~s) or A (.. 3Zl... \"ym)---+ As (ees) Ap (.. \"yp) . We will only assume that the production is A (..q,~ ... q,,,) ~ Ap (.. 7p)As (c~s). Arguments similar to the one given below can be used when the production of the form in P [i + dp, d -dp].",
                "cite_spans": [
                    {
                        "start": 187,
                        "end": 195,
                        "text": "(.. \"yp)",
                        "ref_id": null
                    },
                    {
                        "start": 243,
                        "end": 259,
                        "text": "(..q,~ ... q,,,)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "In order to show the existence of the appropriate type of entry corresponding to the derivation of ai... ai+cl-1 from A (fl), we need to consider whether A (fl) satisfies the TC-property in this derivation. This could depend on whether the primary constituent A, (flpVp) does. Since the inductive hypothesis applies for the derivation Ap (flVp) G ai... ai+dp-1. Let us start by assuming that A (fl) satisfies the TC-property. This means that it has a (say) (k + 1)-terminator whose stack length is greater than or equal to TTC.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Expressing fl as flt71 ... 7k, we can then rewrite the derivation from A (fl) as follows. where At (fltq/t) is the terminator of Ap (fltq/~... q/kq/p). Thus, len (fltq/t) ~ TTC and k _> 1. Now, At (fltq/t) is the terminator of A (fltq/1 .'' q/k) if and only if k > 1 (from Observation 2.5).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Let k > 1. At (fltq/t) is the terminator of A (fltq/1 ... q/k) and len (fit'~t) >_ TTC. Thus, A (fltq/1 ..\" q/k) satisfies the TC-property. Therefore we must show that the entry ((A, q/k) (q/1 ... q/k-l, ((At, q/t)~ [t, dt]))) belongs to P [i,d] . By inductive hypothesis we may assume ( (Ap, q/p) (\"/1. . . q/k, ((At, q/t) , [t, dt]))) belongs to P [i, dp] . Now all the conditions in the antecedent of Rule 3.ps.L have been met and thus we have shown the existence of the appropriate entry to record the derivation of ai... ai+d_l from A (fl).",
                "cite_spans": [
                    {
                        "start": 240,
                        "end": 245,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 286,
                        "end": 297,
                        "text": "( (Ap, q/p)",
                        "ref_id": null
                    },
                    {
                        "start": 298,
                        "end": 312,
                        "text": "(\"/1. . . q/k,",
                        "ref_id": null
                    },
                    {
                        "start": 313,
                        "end": 318,
                        "text": "((At,",
                        "ref_id": null
                    },
                    {
                        "start": 319,
                        "end": 323,
                        "text": "q/t)",
                        "ref_id": null
                    },
                    {
                        "start": 350,
                        "end": 357,
                        "text": "[i, dp]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Let k --1. From Observation 2.5 it follows that the k'-terminator of Now any k-terminator of Ap (tipq/p) is also the k-terminator of A (tipq/1) (and if Ap (tipq/,) has no terminator then neither does A (flpq/1)). That is, A (flpq/1) satisfies the WCproperty in this derivation if and only if Ap (fl/~p) does. If Ap (flpq/p) does not satisfy the TC-property, then, by inductive hypothesis, we have ((Am, q/p)(tip, nil)) c P [i, dp] .",
                "cite_spans": [
                    {
                        "start": 144,
                        "end": 163,
                        "text": "(and if Ap (tipq/,)",
                        "ref_id": null
                    },
                    {
                        "start": 423,
                        "end": 430,
                        "text": "[i, dp]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Thus the entries corresponding to the antecedents of Rule 6.ps.L exist and the algorithm would have added the entry ((A,q/1)(tip,nil)) c P [i,d] Applying the inductive hypothesis we have ((As, top (C~s) ) (rest (C~s), nil)) E P [i +dp, d -dp].",
                "cite_spans": [
                    {
                        "start": 139,
                        "end": 144,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 187,
                        "end": 202,
                        "text": "((As, top (C~s)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "Since Ap (flp3`p) is the m-terminator of A (tip3`1... 3`m), we have to consider its length in order to know whether A (flp'Yl ... 3`m) satisfies the TC-property, i.e., how it must be represented. Suppose len (flp3`p) < TTC, then by inductive hypothesis we have the entry ((Ap, 3`p) (tip,nil)) E P [i, dp] . Thus all antecedents of Rule 9.ps.C have been found. Since the terminator of A (tip3`1 ... 3`m) has a stack of length less than TTC, the required entry, ((A, nil) ), is added by the algorithm by the application of Rule 9.ps.L. Suppose len (flp3`p) >__ TTC, then Ap (flp3`p) may or may not be represented as a terminator-type entry. Let us take the case where Ap (flp3`p) does not satisfy the WC-property. Again by inductive hypothesis, we have the entry ((Ap, 3'p)(tip, nil) ) E P [i, dp] . Since len (flp3`p) > TTC and the antecedents entries of Rule 10.ps.L exist, the algorithm would add ((A, 3`m)(3'1-.. 3`m--1~ (~ap~ 3`pl ~ [i~dp]))) to P[i~d] as desired. If we had assumed Ap (flp3`p) satisfies the TC-property, then by applying the inductive hypothesis we can guarantee the existence of the entries corresponding to the antecedent of Rule 8.ps.L, and therefore the algorithm would have added ((A~ 3`m)(3`1 ..-3`m-1, ( (Ap, \"YPI , [i, dp] ) ) )",
                "cite_spans": [
                    {
                        "start": 116,
                        "end": 134,
                        "text": "A (flp'Yl ... 3`m)",
                        "ref_id": null
                    },
                    {
                        "start": 297,
                        "end": 304,
                        "text": "[i, dp]",
                        "ref_id": null
                    },
                    {
                        "start": 460,
                        "end": 464,
                        "text": "((A,",
                        "ref_id": null
                    },
                    {
                        "start": 465,
                        "end": 469,
                        "text": "nil)",
                        "ref_id": null
                    },
                    {
                        "start": 761,
                        "end": 766,
                        "text": "((Ap,",
                        "ref_id": null
                    },
                    {
                        "start": 767,
                        "end": 776,
                        "text": "3'p)(tip,",
                        "ref_id": null
                    },
                    {
                        "start": 777,
                        "end": 781,
                        "text": "nil)",
                        "ref_id": null
                    },
                    {
                        "start": 788,
                        "end": 795,
                        "text": "[i, dp]",
                        "ref_id": null
                    },
                    {
                        "start": 1230,
                        "end": 1251,
                        "text": "( (Ap, \"YPI , [i, dp]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "to P [i, d] as desired.",
                "cite_spans": [
                    {
                        "start": 5,
                        "end": 11,
                        "text": "[i, d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Completeness:",
                "sec_num": null
            },
            {
                "text": "For instance, consider the grammar in Example 2.1 and the derivation inFigure 1. In general we can have derivations of the form T (q'a3\"~) ~ cab n. However, if there exists productions of the form A (c~) --~ ~ then the length of the stack in objects is not even bounded by the length of strings they derive. 4 The CCG parsing algorithms that have been proposed so far follow this strategy(Pareschi and Steedman 1987;Tomita 1988).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Similar arguments can be used when we consider the production: A (.. 3' 1 ... 7m) --* As (C~s) Ap (\" 3'p).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "Here L indicates a rule we use in LIG parsing; ps indicates that the primary constituent appears before the secondary constituent. Similarly, sp will be used to indicate that the secondary constituent appears before the primary constituent.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            }
        ],
        "back_matter": [
            {
                "text": "This work has been partially supported by NSF Grants IRI-8909810 and IRI-9016591. We would like to thank A. K. Joshi, B. Lang, Y. Schabes, S. M. Shieber, and M. J. Steedman for many discussions. We are grateful to the anonymous reviewers for their numerous suggestions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Acknowledgments",
                "sec_num": null
            },
            {
                "text": "As in the second part of Case 6 of the LIG construction (i.e., when there is no OA constraint at the node ~7) we have the following counterparts of Rule 6.u.L and Rule 7.u.L: Rule 6.i.u.T OA(rl) =false ((b,r/)(r]t,t, dt)) E P [i,d] ((t,\u2022) (,t,t, dt)) E P [i,d] Rule 7.i.u.T OA(~)) =false ((b,~7) ,nil) E P [i,d] ((t, rl) ,nil) E P [i,d] Left sibling on the spine: This corresponds to Case 2 of the LIG construction. The following rule that captures this situation corresponds to Rule 7.ps.L.Rule 7.ps.T~p is left child of ~?p is on the spine of an auxiliary tree ((t,~/p/(,,,t, dt)) E P [i, dp] ~/p is right child of 7/ ((t, ~/s), nil) C P [i + dp, d -dp] ((b,,) 01t, t, dt) ) C P [i,d] The following covers Case 4 of LIG construction where the two siblings are not on the spine or belong to an initial tree and corresponds to Rule 6.ps.L (or Rule 6.sp.L).Rule 6.ps.T r/p is left child of z/ r/is not on the spine of any auxiliary tree ((t,,p} ,nil) C P [i, dp] ~p is right child of (t, rls}, nil) E P [i + dp, d --dp] ((b, rl} ,nil) E P [i,d] Right sibling on the spine: Corresponding to Case 3 of LIG construction and Rule 7.sp.L we have Rule 7.sp.T rls is left child of ~1 ((t,,s} ,nil) E P [i, ds] ~/p is right child of Wp is on the spine of an auxiliary tree ((t,,p} (Zlt, t, dt) Appendix A: Correctness of Algorithm 1We will now prove the correctness of Algorithm 1. In doing so, we will start by observing some properties of the rules and the control structure used.Firstly, given an input is al... an, we can note that every entry added by a rule (i.e., consequents of rules) satisfies the requirements for the terminator-type and nonterminator-type entries; viz., if ((A,'y)(/3, ((At, \"Yt), It, dr]))) is added to an array ele-We can also note that if ( (A,'71 (fl, nil) \u2022 d>_l.These can be verified from noting the form of the rules and by simple induction on (i, d/. We can also observe from the control structure given that entries to P [il, dl ] (il,dll < (i3,d31 or (/1, dl) = (/3, d3) and (/2, d2) > (/4, dd). This observation can be used to show that when a rule is considered for the purposes of adding an entry to P [il,dl] [/2,d2] then the array elements specified in the antecedent of that rule would have already been filled. Verifying these properties of the algorithm enables us to establish the correctness of the algorithm more easily. ((A,7) (o~,nil)) E P [i,d] if and only ifwhere A (a7) does not have the TC-property, i.e., A (aT) has no terminator in this derivation or the terminator, say At (fl3q), is such that len (flTt) < TTC.",
                "cite_spans": [
                    {
                        "start": 226,
                        "end": 231,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 255,
                        "end": 260,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 288,
                        "end": 295,
                        "text": "((b,~7)",
                        "ref_id": null
                    },
                    {
                        "start": 306,
                        "end": 320,
                        "text": "[i,d] ((t, rl)",
                        "ref_id": null
                    },
                    {
                        "start": 331,
                        "end": 336,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 587,
                        "end": 594,
                        "text": "[i, dp]",
                        "ref_id": null
                    },
                    {
                        "start": 681,
                        "end": 686,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 954,
                        "end": 961,
                        "text": "[i, dp]",
                        "ref_id": null
                    },
                    {
                        "start": 1038,
                        "end": 1043,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 1194,
                        "end": 1201,
                        "text": "[i, ds]",
                        "ref_id": null
                    },
                    {
                        "start": 1264,
                        "end": 1284,
                        "text": "((t,,p} (Zlt, t, dt)",
                        "ref_id": null
                    },
                    {
                        "start": 1949,
                        "end": 1958,
                        "text": "[il, dl ]",
                        "ref_id": null
                    },
                    {
                        "start": 1959,
                        "end": 1979,
                        "text": "(il,dll < (i3,d31 or",
                        "ref_id": null
                    },
                    {
                        "start": 2134,
                        "end": 2141,
                        "text": "[il,dl]",
                        "ref_id": null
                    },
                    {
                        "start": 2382,
                        "end": 2387,
                        "text": "[i,d]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 1763,
                        "end": 1779,
                        "text": "(A,'71 (fl, nil)",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "annex",
                "sec_num": null
            },
            {
                "text": "We prove the soundness by inducting on d. The base case corresponds to d = 1. We have to consider only entries of the form ((A,'y)(c~,nil)) in P [i, 1] . Such entries are added only by the application of Rule 1. Therefore, we have A (~/) --+ a and a = ai. Hence A (c~,y) ~ ai as required. Now, for the inductive step, let d > 2. Any entry ((A,3'/(a, tp)) added to P [i,d] where d > 2 must be due to a rule other than Rule 1.L. This means that we have either a production A As (C~s) or A (.. 71... \"Ym) --+ As (O~s) A m ('\" q/p). Let us assume that the first production was used. We will discuss the cases for m = 0, m = 1, and m _> 2 separately.Let m = 0. In this case the production is A (..) --* Ap (.. \",/p) As (as). Then the entry ((A, \"~) (a, tp)) should have been added by using one of rules 1.ps.L through 5.ps.L. We take Rule 4.ps.L as a representative. If ((A, \"Yl) (fit, nil)) were to be added as a result of this rule, then we have to show that A (fit\"Y1) :~ ai... ai+d-1 where A (fit\"Y1) does not meet the TC-property. Since (i, dp) < (i, d I, (i +dp, d -ds) < (i, d) , and (t, tit) ( (i, d) the inductive hypothesis applies to the three entries in the antecedent. Thus, we have for some a the following derivations: ",
                "cite_spans": [
                    {
                        "start": 145,
                        "end": 151,
                        "text": "[i, 1]",
                        "ref_id": null
                    },
                    {
                        "start": 366,
                        "end": 371,
                        "text": "[i,d]",
                        "ref_id": null
                    },
                    {
                        "start": 1047,
                        "end": 1079,
                        "text": "(i, d I, (i +dp, d -ds) < (i, d)",
                        "ref_id": null
                    },
                    {
                        "start": 1095,
                        "end": 1103,
                        "text": "( (i, d)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Proof of Soundness:",
                "sec_num": null
            }
        ],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "Indexed grammars--An extension to context free grammars",
                "authors": [
                    {
                        "first": "A",
                        "middle": [
                            "V"
                        ],
                        "last": "Aho",
                        "suffix": ""
                    }
                ],
                "year": 1968,
                "venue": "J. ACM",
                "volume": "15",
                "issue": "",
                "pages": "647--671",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Aho, A. V. (1968). \"Indexed grammars--An extension to context free grammars.\" J. ACM, 15, 647-671.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Linear indexed languages",
                "authors": [
                    {
                        "first": "J",
                        "middle": [],
                        "last": "Duske",
                        "suffix": ""
                    },
                    {
                        "first": "R",
                        "middle": [],
                        "last": "Parchmann",
                        "suffix": ""
                    }
                ],
                "year": 1984,
                "venue": "Theoretical Comput. Sci",
                "volume": "32",
                "issue": "",
                "pages": "47--60",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Duske, J., and Parchmann, R. (1984). \"Linear indexed languages.\" Theoretical Comput. Sci., 32, 47-60.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "Applicability of indexed grammars to natural languages",
                "authors": [
                    {
                        "first": "G",
                        "middle": [],
                        "last": "Gazdar",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "Natural Language Parsing and Linguistic Theories",
                "volume": "",
                "issue": "",
                "pages": "69--94",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Gazdar, G. (1988). \"Applicability of indexed grammars to natural languages.\" In Natural Language Parsing and Linguistic Theories, edited by U. Reyle and C. Rohrer. D. Reidel, 69-94.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "How much context-sensitivity is necessary for characterizing structural descriptions--tree adjoining grammars",
                "authors": [
                    {
                        "first": "A",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    },
                    {
                        "first": "L",
                        "middle": [],
                        "last": "Dowty",
                        "suffix": ""
                    },
                    {
                        "first": "A",
                        "middle": [],
                        "last": "Karttunen",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Zwicky",
                        "suffix": ""
                    }
                ],
                "year": 1985,
                "venue": "Natural Language Processing--Theoretical, Computational and Psychological Perspective",
                "volume": "",
                "issue": "",
                "pages": "206--250",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Joshi, A. K. (1985). \"How much context-sensitivity is necessary for characterizing structural descriptions--tree adjoining grammars.\" In Natural Language Processing--Theoretical, Computational and Psychological Perspective, edited by D. Dowty, L. Karttunen, and A. Zwicky. Cambridge University Press, 206-250.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "Tree adjunct grammars",
                "authors": [
                    {
                        "first": "A",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    },
                    {
                        "first": "L",
                        "middle": [
                            "S"
                        ],
                        "last": "Levy",
                        "suffix": ""
                    },
                    {
                        "first": "M",
                        "middle": [],
                        "last": "Takahashi",
                        "suffix": ""
                    }
                ],
                "year": 1975,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Joshi, A. K.; Levy, L. S.; and Takahashi, M. (1975). \"Tree adjunct grammars.\" ].",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "An efficient recognition and syntax algorithm for context-free languages",
                "authors": [
                    {
                        "first": "T",
                        "middle": [],
                        "last": "Kasami",
                        "suffix": ""
                    }
                ],
                "year": 1965,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kasami, T. (1965). \"An efficient recognition and syntax algorithm for context-free languages.\" Technical Report AF-CRL-65-758, Air Force Cambridge Research Laboratory, Bedford, MA.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "Towards a uniform formal framework for parsing",
                "authors": [
                    {
                        "first": "B",
                        "middle": [],
                        "last": "Lang",
                        "suffix": ""
                    }
                ],
                "year": 1990,
                "venue": "Current Issues in Parsing Technology",
                "volume": "",
                "issue": "",
                "pages": "153--171",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Lang, B. (1990). \"Towards a uniform formal framework for parsing.\" In Current Issues in Parsing Technology, edited by M. Tomita. Kluwer Academic Publishers, 153-171.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "A lazy way to chart-parse with categorial grammars",
                "authors": [
                    {
                        "first": "R",
                        "middle": [],
                        "last": "Pareschi",
                        "suffix": ""
                    },
                    {
                        "first": "M",
                        "middle": [
                            "J"
                        ],
                        "last": "Steedman",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "Proceedings, 25th Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "81--88",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Pareschi, R., and Steedman, M. J. (1987). \"A lazy way to chart-parse with categorial grammars.\" In Proceedings, 25th Meeting of the Association for Computational Linguistics, 81-88.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "Generalized Phrase Structure Grammars, Head Grammars and Natural Language. Doctoral dissertation",
                "authors": [
                    {
                        "first": "C",
                        "middle": [],
                        "last": "Pollard",
                        "suffix": ""
                    }
                ],
                "year": 1984,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Pollard, C. (1984). Generalized Phrase Structure Grammars, Head Grammars and Natural Language. Doctoral dissertation, Stanford University.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "Combinators and grammars",
                "authors": [
                    {
                        "first": "M",
                        "middle": [],
                        "last": "Steedman",
                        "suffix": ""
                    }
                ],
                "year": 1986,
                "venue": "Categorial Grammars and Natural Language Structures",
                "volume": "",
                "issue": "",
                "pages": "417--442",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Steedman, M. (1986). \"Combinators and grammars.\" In Categorial Grammars and Natural Language Structures, edited by R. Oehrle, E. Bach, and D. Wheeler. Foris, 417-442.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "Dependency and coordination in the grammar of Dutch and English",
                "authors": [
                    {
                        "first": "M",
                        "middle": [
                            "J"
                        ],
                        "last": "Steedman",
                        "suffix": ""
                    }
                ],
                "year": 1985,
                "venue": "Language",
                "volume": "61",
                "issue": "",
                "pages": "523--568",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Steedman, M. J. (1985). \"Dependency and coordination in the grammar of Dutch and English.\" Language, 61:523-568.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "Graph-structured stack and natural language parsing",
                "authors": [
                    {
                        "first": "M",
                        "middle": [],
                        "last": "Tomita",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "Proceedings, 26th Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "248--257",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Tomita, M. (1988). \"Graph-structured stack and natural language parsing.\" In Proceedings, 26th Meeting of the Association for Computational Linguistics, 248-257.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "A study of tree adjoining grammars. Doctoral dissertation",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K. (1987). A study of tree adjoining grammars. Doctoral dissertation, University of Pennsylvania, Philadelphia, PA.",
                "links": null
            },
            "BIBREF14": {
                "ref_id": "b14",
                "title": "Some computational properties of tree adjoining grammars",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    },
                    {
                        "first": "A",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 1985,
                "venue": "Proceedings, 23rd Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "82--93",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K., and Joshi, A. K. (1985). \"Some computational properties of tree adjoining grammars.\" In Proceedings, 23rd Meeting of the Association for Computational Linguistics, 82-93.",
                "links": null
            },
            "BIBREF15": {
                "ref_id": "b15",
                "title": "The equivalence of four extensions of context-free grammars",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    },
                    {
                        "first": "D",
                        "middle": [
                            "J"
                        ],
                        "last": "Weir",
                        "suffix": ""
                    }
                ],
                "year": null,
                "venue": "Mathematical Systems Theory",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K., and Weir, D. J. (In press). \"The equivalence of four extensions of context-free grammars.\" Mathematical Systems Theory.",
                "links": null
            },
            "BIBREF16": {
                "ref_id": "b16",
                "title": "Polynomial parsing of combinatory categorial grammars",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    },
                    {
                        "first": "D",
                        "middle": [
                            "J"
                        ],
                        "last": "Weir",
                        "suffix": ""
                    }
                ],
                "year": 1990,
                "venue": "Proceedings, 28th Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "1--8",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K., and Weir, D. J. (1990). \"Polynomial parsing of combinatory categorial grammars.\" In Proceedings, 28th Meeting of the Association for Computational Linguistics, Pittsburgh, PA, 1-8.",
                "links": null
            },
            "BIBREF17": {
                "ref_id": "b17",
                "title": "The use of shared forests in TAG parsing",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    },
                    {
                        "first": "D",
                        "middle": [
                            "J"
                        ],
                        "last": "Weir",
                        "suffix": ""
                    }
                ],
                "year": 1993,
                "venue": "Proceedings, 6th Meeting of the European Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "384--393",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K., and Weir, D. J. (1993). \"The use of shared forests in TAG parsing.\" In Proceedings, 6th Meeting of the European Association for Computational Linguistics, Utrecht, The Netherlands, 384-393.",
                "links": null
            },
            "BIBREF18": {
                "ref_id": "b18",
                "title": "Characterizing mildly context-sensitive grammar formalisms. Doctoral dissertation",
                "authors": [
                    {
                        "first": "D",
                        "middle": [
                            "J"
                        ],
                        "last": "Weir",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Weir, D. J. (1988). Characterizing mildly context-sensitive grammar formalisms. Doctoral dissertation, University of Pennsylvania, Philadelphia, PA.",
                "links": null
            },
            "BIBREF19": {
                "ref_id": "b19",
                "title": "Combinatory categorial grammars: Generative power and relationship to linear context-free rewriting systems",
                "authors": [
                    {
                        "first": "D",
                        "middle": [
                            "J"
                        ],
                        "last": "Weir",
                        "suffix": ""
                    },
                    {
                        "first": "A",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "Proceedings, 26th Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "278--285",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Weir, D. J., and Joshi, A. K. (1988). \"Combinatory categorial grammars: Generative power and relationship to linear context-free rewriting systems.\" In Proceedings, 26th Meeting of the Association for Computational Linguistics, 278-285.",
                "links": null
            },
            "BIBREF20": {
                "ref_id": "b20",
                "title": "Recognition and parsing of context-free languages in time n3",
                "authors": [
                    {
                        "first": "D",
                        "middle": [
                            "H"
                        ],
                        "last": "Younger",
                        "suffix": ""
                    }
                ],
                "year": 1967,
                "venue": "Inf. Control",
                "volume": "10",
                "issue": "2",
                "pages": "189--208",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Younger, D. H. (1967). \"Recognition and parsing of context-free languages in time n3. \" Inf. Control, 10(2), 189-208.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF0": {
                "type_str": "figure",
                "text": "Figure 1",
                "uris": null,
                "num": null
            },
            "FIGREF1": {
                "type_str": "figure",
                "text": "1. A (c0 ~ c where ~ C VT U {c} and length of c~, len (,9<) >>_ 1. 2. A (.. \"/1... Q/m) ----> Ap (.. Vp) As (O<s) where m > 0.",
                "uris": null,
                "num": null
            },
            "FIGREF2": {
                "type_str": "figure",
                "text": "Figure 5 Algorithm 1.",
                "uris": null,
                "num": null
            },
            "FIGREF3": {
                "type_str": "figure",
                "text": "Given a grammar G and an input al...an an entry ((A, q/} (fl, tp)) is added to P[i,d]   by Algorithm 1 if and only if ((A,q/) (fl, tp)) is added to P[i,d]  by Algorithm 2. Outline of Proof: Using induction on d. The base case corresponding to d = 1 involves only the initialization step, which is the same in the two algorithms. The only difference between the two algorithms (apart from the control structure) is the use of Rule 5.ps.L (and Rule 5.sp.L) by Algorithm 1 versus the use of Rule 5.i.ps.L and Rule 5.ii.ps.L (Rule 5.i.sp.L and Rule 5.i.sp.L) in Algorithm 2. Rule 5.ps.L is used to add entries of the form ((A, ~Yl)(fit, ((ar~ q/r)~ Jr, dr]))). We can establish that ((A, ,`/1) (fit, ((Ar, q/r), [r, dr]))) is added to P [i, d] due to the application of Rule 5.ps.L if and only if there exist entries of the form (",
                "uris": null,
                "num": null
            },
            "FIGREF5": {
                "type_str": "figure",
                "text": "Figure 6 Algorithm 2.",
                "uris": null,
                "num": null
            },
            "FIGREF6": {
                "type_str": "figure",
                "text": "G, is denoted by (VT, VN, S~f~ R) where VT is a finite set of terminals (lexical items), VN is a finite set of nonterminals (atomic categories), S is a distinguished member of VN, f is a function that maps each element of VT to a finite set of categories, R is a finite set of combinatory rules, where combinatory rules have the following form. 1. A forward rule has the following form where m > 0. (x/y) (yllZl[2... ImZm) ---4. (XllZll2... [mZm) 2. A backward rule has the following form where m > 0. (y11Zl12... ImZm) (x\\y) ---+ (XIIZl12..",
                "uris": null,
                "num": null
            },
            "FIGREF7": {
                "type_str": "figure",
                "text": "If c C f(a) for some a c VT and c is a category, then TlCT2 ~ TlaT2.The string languages generated by a CCG, G, L(G) = { w ] S ~ w ] w E V~ }. G Example 4.1 The following CCG generates { wcw ] w E {a, b} + }. Let G = ({at b, c}, {S, T, A, B}, S,f, R) where f(a) = (A, T\\A/T, T\\A} f(b) = {B, T\\B/T, T\\B} f(c) = (S/T}",
                "uris": null,
                "num": null
            },
            "FIGREF8": {
                "type_str": "figure",
                "text": "Figure 7 CCG example derivation tree.",
                "uris": null,
                "num": null
            },
            "FIGREF9": {
                "type_str": "figure",
                "text": "Let a category c = AllC112... [nCn be in minimally parenthesized such that n > 0, A E VN, and Cl,..., Cn are minimally parenthesized categories. \u2022 The target category of c = allClI2... InCn denoted by tar(c) is A. \u2022 The arity of c = AllC112... InCn, denoted as arity (c), is n. \u2022 The argument categories of c = AllC 112... Inch denoted by args (c) = { ci ] 1 < i < n }.",
                "uris": null,
                "num": null
            },
            "FIGREF10": {
                "type_str": "figure",
                "text": "Let c be a useful category with respect to a grammar G if and only if c ~ w for some w E V~. The set of argument categories, args (G) of a CCG, G = (VT~ VN~ S,f, R), is defined as args (G) = Uc~f(a) args (c).",
                "uris": null,
                "num": null
            },
            "FIGREF11": {
                "type_str": "figure",
                "text": "If c is a useful category then args (c) c args (G), a finite set determined by the grammar, G. This observation can be shown by an induction on the length of the derivation of some string from c. The base case corresponds to a lexical assignment and hence trivially args (c) C args (G). The inductive step corresponds to the use of a combination using a rule of the form (x/y) (yllZll2... ImZm) ---+ (XIlZll2... ImZm ) or (yllZll2...]mZm) (x\\y) ~ (XIlZll2...ImZm) By inductive hypothesis, any useful category matching either (x/y)} (x\\y) or",
                "uris": null,
                "num": null
            },
            "FIGREF12": {
                "type_str": "figure",
                "text": "-. ]nCn) = n. Note that arity ((A]1c112... InCn)) = len ([1Cl]2... ]nCn) = n. We define top ((IlCl]2... InCn)) = [nCn and rest ((]1c112... ]nCn)) = ]1Cl ]2.-. ]n--lCn--1 \u2022 Additionally, top (\u00a2) = rest (~) = \u00a2.",
                "uris": null,
                "num": null
            },
            "FIGREF13": {
                "type_str": "figure",
                "text": "",
                "uris": null,
                "num": null
            },
            "FIGREF14": {
                "type_str": "figure",
                "text": ", top(as))(rest(o~s),nil) ) C P[i + de,d-de] ( (Ap, IkCk) (llCl... Ik_lCk_i, tpp) ) ~ P[i,d]Rule 4.ps.C ((ap,/ep) (lie1, ((]tct), [t, dt]) ) ) E P[i, dp] Asc~s = Cp ((As, top (cts)) (rest (C~s), nil) ) , ]tct) tit, nil * P[t, dt] ((Ap, I1c,) (tit,nil)) C P[i,d] Rule 5.ps.C",
                "uris": null,
                "num": null
            },
            "FIGREF15": {
                "type_str": "figure",
                "text": ", top (C~s)) (rest (C~s), nil)) cP[i+dp,d-de]    tpt-~ ((IrCr),[r, dr])",
                "uris": null,
                "num": null
            },
            "FIGREF16": {
                "type_str": "figure",
                "text": "If there exists a production A (.. 71 ... 2/m) -+ A m ('\" 7p) As (C~s) where m >__ 2, el = ((Ap,q'p)(flp,(at,'Tt))) belongs to P[i,d][t, dt]  and e2 = ((As, top (C~s))(rest (c~s), nil)) belongs to P[i +dp, d -dp] [0, 0] then add e3 = ((A~'ym)(qrl...~/m-l,(Ap~2/p))) to P[i,d][i~dp] if e3 is not already present in this array element.",
                "uris": null,
                "num": null
            },
            "FIGREF17": {
                "type_str": "figure",
                "text": "Figure 9",
                "uris": null,
                "num": null
            },
            "FIGREF18": {
                "type_str": "figure",
                "text": "Domain (-y') = {/.1 I /.1 E Domain(7),/.1 ~/*'/*2, for some/*2 E Af*} U {/* \",1 [/.1 E Domain (fl)} U {#. ft (fl)'/~l I/* \"/.1 C Domain (3'), and/.1 \u2022 e} \u2022 When/.1 C Domain (3`) such that/.1 #/* \u2022/.1 for some/.1 E d~ f*}, i.e., the node in ~ with address/.1 is not equal to or dominated by the node addressed/*'>1 E Domain (7') such that#1 C Domain(fl): LABEL(7',/*. >1) = LABEL(fl,/*I), ',/*'/*1) ~-OA(fl,/.1), \u2022 when/*, ft (fl)./.1 E Domain (3\") such that/*./.1 C Domain (7) and/.1 # e: LABEL ('T t,/*-ft (/3). /.1) = LABEL (-y, #./xl ), , # \u2022 ft (fl) -it1 ) = SA('y,# -#1}, OA(~/', # -ft (fl). #~) = OA(%#. #1),",
                "uris": null,
                "num": null
            },
            "FIGREF19": {
                "type_str": "figure",
                "text": "Figure 11 Sample derivations in G.",
                "uris": null,
                "num": null
            },
            "FIGREF20": {
                "type_str": "figure",
                "text": "Figure 13 TAG/LIG relationship.",
                "uris": null,
                "num": null
            },
            "FIGREF22": {
                "type_str": "figure",
                "text": "fl, ft(fl)) fl c SA(7) ((b,7) (~h,t, dt)) E P[i,d]   ((b, 111) (7, i,d) ) C P[i,d]Rule 10.u.T 7, = (fl~ft(fl)) fl C SA(7) ((b~7)~nil) E P[i~d] ((b, 71) (7, i,d)) E P[i,d] Rule 6.ii.u.T ~/p is only child of ~/is not on the spine of any auxiliary tree",
                "uris": null,
                "num": null
            },
            "FIGREF23": {
                "type_str": "figure",
                "text": "A (.. \"~1 ... 7m) --+ As (%) Ap (.. %) is involved as the first step of the derivation. Case m = 0: We begin by considering the case when m = 0. Since the first production used in A (fl) =~ ai. . . ai+d-1 is A (..) ---+ Ap (.. \"yp) As (C~s), we can write the derivation as A (fl) ~ Ap (9\"Yp) As (c~s) ai . . .ai+dp-lAs (o~s) ai . . . ai+dp-lai+4 . . . ai+d-1 for some I < dp< d and lp + ls = I. Applying the inductive hypothesis to the derivation As (o@) ~ ai+clp ... ai+d-1, we can assume the existence of the entry (IAs, tOp(~s)) (rest(C~s),nil) )",
                "uris": null,
                "num": null
            },
            "FIGREF24": {
                "type_str": "figure",
                "text": "At (fltq/t) (if it exists) is also the k~-terminator of A (fltq/1), and if At(fltq/t)   has no terminator then neither does A (fltq/1). Therefore A (fl) = A (flt'yl) satisfies the TC-property if and only if At (fit'~t) does.Suppose At (fltq/t) satisfies the TC-property; then all conditions stated in the antecedent of Rule 5.ps.L are met and the appropriate entry is added to record the derivation from A (fl). On the other hand, if At (fit'/t) does not satisfy the TC-property then all conditions stated in the antecedent of Rule 4.ps.L are met and the appropriate entry is added to record the derivation from A (fl). Case m = 1\" Here we are concerned with the situation where A (.. \")/1) ---+ Ap (.-q/p) As (as) is the first production used in the derivation of ai... ai+d-1 from A (fl). Rewriting fl as flpq/1 we have A (flpq/1) ~ Ap (flpq/p) As(~s) a i ...... ai+dp-lai+dp \u2022.. ai+d_l Applying the inductive hypothesis we have ((As, top (C~s) ) (rest (o~s), nil)) c P [i +dp, d -dp] .",
                "uris": null,
                "num": null
            },
            "FIGREF25": {
                "type_str": "figure",
                "text": "as desired. If A m (flpq/p) does satisfy the TC-property then Rule 7.ps.L would add the required entry to record the derivation from A (fl). Case m > 2\" Finally, consider that case when m > 2. The given derivation may be expressed as A (flpq/,...q/m) =~ Ap (flpq/p) As (as) ai ...... ai+dp-l ai+dp \u2022 \u2022 \u2022 ai+d-1 = ai \u2022 \u2022 .ai+d-1",
                "uris": null,
                "num": null
            },
            "TABREF2": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": ")E P[i, dp]. This is consistent with the rule's primary constituent. Regardless of whether tpp = nil or not, for some",
                "content": "<table/>"
            },
            "TABREF4": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "If the primary constituent is Ap (titip,,/p) then the new constituent is A (tiflp'Yl... \"/m). In fact, in this case, we have the primary constituent being the m-terminator ofA (fltip3'l... \"Ym). Of course, this does not mean that the derivation from the new object",
                "content": "<table><tr><td>Rule 7.ps.L</td><td/></tr><tr><td>( (Ap, 7p) (tip, ((At, 7t) , [t, dt] ) ) ) \u00a2 P [i, dp]</td><td>( ( A~ , top ( c~s ) ) (rest(as), nil)) E P [ i + dp , d -dp ]</td></tr><tr><td>CASE WHEN m &gt; 2</td><td/></tr></table>"
            },
            "TABREF6": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": ").A minimally parenthesized category (AIlc 112... InCn) can be viewed as the atomic category, A, associated with a stack of directional argument categories, ILC112... Inc,. Thus x matches the category(Apl~c ~ ... [nCn), y matches an atomic category As in the first example and a nonatomic category (As]~C ') in the second, and each zi matches ci for 1 ( i ( m. A derivation involving the second instance (viewed bottom-up) can be seen as popping the top directional argument /(Asl'c') from the primary category and pushing the m directional arguments IlCl]2.-. ImCm \u2022 Thus, each instance of the combinatory rule appears to closely resemble a LIG production. For example, in case of the second instance we have ap (.. ILC112...",
                "content": "<table><tr><td colspan=\"3\">as an instance. ImCm) ---+ ap (../(As]'c')) As</td><td>! !</td><td/></tr><tr><td>The rule</td><td/><td/><td/><td/></tr><tr><td/><td colspan=\"3\">(x/y) (yllZll2... ImZm) ~ (XI1Zll2... ImZm)</td><td/></tr><tr><td colspan=\"5\">! ! has as an instance (ApieCe... InCh~As) (AsliCl}2... ImCm) --~ (apieCe... InCnllCll2... ImCm) ! !</td></tr><tr><td>I</td><td>I</td><td>I I</td><td>I</td><td>I</td></tr></table>"
            },
            "TABREF8": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "Suppose that we have the following derivation: Assuming the terminator derives the substring at... at+d~-l, we can use the terminator-pointer (llctl~ [t~ dtl) and a middle I1c1... Ik_lCk_l . Notice that since the target of the category Alfl]lcl... Ik-lCk-11C as well as the target of its terminator is A and since A is already noted in the head, it is not recorded in the terminator-pointer.For entries that are not terminator-pointer, the entire category is noted in the entry. Such an entry has the form",
                "content": "<table><tr><td/><td>4.7</td><td/><td/></tr><tr><td/><td colspan=\"2\">aflllCl . . . Ik_lCk_llC ~</td><td colspan=\"2\">u aflllCl .. . ]k_lCk_llkCk. . . ImCm</td><td>W</td></tr><tr><td/><td/><td colspan=\"2\">==~ U afl/Cp</td><td>CpllCl . . . IkCk. . . ImCm</td><td>W</td></tr><tr><td/><td/><td/><td>ldVW</td></tr><tr><td colspan=\"2\">or similarly</td><td/><td/></tr><tr><td/><td>aflllCl...Ik_lCk-llC</td><td>~</td><td colspan=\"2\">U aflllCl...Ik_lCk_llkCk...ImC</td><td>m W</td></tr><tr><td/><td/><td/><td colspan=\"2\">u CpllCl...[kCk...ImCm Aft\\c, w</td></tr><tr><td/><td/><td/><td>UVW</td></tr><tr><td colspan=\"3\">where the following conditions hold</td><td/></tr><tr><td colspan=\"5\">\u2022 fl is a string of direction categories, i.e., fl E ({/~ \\}args (G))*.</td></tr><tr><td>\u2022</td><td>k-l&gt;l,</td><td/><td/></tr><tr><td>\u2022</td><td>AflllCl...</td><td/><td/></tr></table>"
            },
            "TABREF11": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "))) C P [i~ d] if and only if there is some c~ such that Ac~tilc ~ ai... ai+d-1 and the (len (/3) + 1)-terminator (Aozltct) of Ac~tilc derives the string at... at+dr-1 and len (O~ltCt) ~ TTC.",
                "content": "<table/>"
            },
            "TABREF13": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "P Ii, d] Ii, d], which in turn could cause new entries being added back to PIi, d] It, dt], and so on. Thus we have a situation where",
                "content": "<table><tr><td>initialization phase</td></tr><tr><td>for loops for d, i, d' as before</td></tr><tr><td>begin</td></tr><tr><td>consider closure of Rules in Rule set I</td></tr><tr><td>for dt :--d' -1 to 1 do</td></tr><tr><td>for t := i to i + d' -dt do</td></tr><tr><td>repeat</td></tr><tr><td>consider closure of Rules in Rule set II</td></tr><tr><td>for dr := dt -1 to 1 do</td></tr><tr><td>for r := t to t + dt -dr do</td></tr><tr><td>consider closure of Rules 5.ps.L and Rule 5.u.L</td></tr><tr><td>until no new entries are added to P[i,d] [t~dt]</td></tr><tr><td>Figure 8</td></tr></table>"
            },
            "TABREF16": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "where len (flpTp) > TTC. Combining the two derivations, we have:A (tip\"Y1... \"Ym) ap (~p-yp) As (as) ai ...... \u00a2li+dp_ l ai-bdp \u2022.. ai+d_ l ai \u2022 \u2022 \u2022 aiq-d-I",
                "content": "<table><tr><td>Ap (tip')p) ~</td><td>ai...ai+dp-1</td></tr><tr><td>As(o@) ~</td><td>ai+dp...ai+d_ 1</td></tr></table>"
            }
        }
    }
}