Base_JSON/prefixE/json/E89/E89-1033.json

{
    "paper_id": "E89-1033",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T10:34:04.247175Z"
    },
    "title": "Interactive Incremental Chart Parsing",
    "authors": [
        {
            "first": "Mats",
            "middle": [],
            "last": "Wirdn",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "LinkSping University",
                "location": {
                    "postCode": "S-58183",
                    "settlement": "LinkSping",
                    "country": "Sweden"
                }
            },
            "email": "mgw@ida.liu.se"
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "This paper presents an algorithm for incremental chart parsing, outlines how this could be embedded in an interactive parsing system, and discusses why this might be useful. Incremental parsing here means that input i8 analysed in a piecemeal fashion, in particular allowing arbitrary changes of previous input without exhaustive reanalysis. Interactive parsing means that the analysis process is prompted immediately at the onset of new input, and possibly that the system then may interact with the user in order to resolve problems that occur. The combination of these techniques could be used as a parsing kernel for highly interactive and ~reactive\" naturallanguage processors, such as parsers for dialogue systems, interactive computer-aided translation systems, and language-sensitive text editors. An incremental chart parser embodying the ideas put forward in this paper has been implemented, and an embedding of this in an interactive parsing system is near completion.",
    "pdf_parse": {
        "paper_id": "E89-1033",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "This paper presents an algorithm for incremental chart parsing, outlines how this could be embedded in an interactive parsing system, and discusses why this might be useful. Incremental parsing here means that input i8 analysed in a piecemeal fashion, in particular allowing arbitrary changes of previous input without exhaustive reanalysis. Interactive parsing means that the analysis process is prompted immediately at the onset of new input, and possibly that the system then may interact with the user in order to resolve problems that occur. The combination of these techniques could be used as a parsing kernel for highly interactive and ~reactive\" naturallanguage processors, such as parsers for dialogue systems, interactive computer-aided translation systems, and language-sensitive text editors. An incremental chart parser embodying the ideas put forward in this paper has been implemented, and an embedding of this in an interactive parsing system is near completion.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "and Introduction",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Background",
                "sec_num": "1"
            },
            {
                "text": "Ideally, a parser for an interactive natural-language system ought to analyse input in real time in such a way that the system produces an analysis of the input while this is being received. One aspect of this is that the system should be able to gkeep up ~ with",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Problem",
                "sec_num": "1.1"
            },
            {
                "text": "This research has been supported by the National Swedish Board for Technical Development. The system is implemented on machines donated by the Xerox Corporation through their University Grants Program.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Problem",
                "sec_num": "1.1"
            },
            {
                "text": "I would like to thank several people for fruitful discussions on the topics of this paper, in particular Lars Ahrenberg (also for commenting on drafts), Bernt Nilsson, and Peter Fritzson; furthermore Nile D~Ibiick, Arne JSnsson, Magnus Merkel, Henry Thompson, and an anonymous referee. In addition, I would like to thank Ulf Dahl~n, Ass Detterfelt, Mikael Karleson, Per Larsee, Jukka Nylund, and Michael Spicar for implementing (the interactive portion of) LIPS. new input that, piece by piece, is entered from left to right. Another aspect is that it ought to be able to keep up also with piecemeal changes of previous input. For example, in changing one word in the beginning of some utterance(s), one would not want all the input (either from the beginning or from the change point) to be completely reanalysed. From the perspective of efficiency as well as of modelling intelligent behaviour, the amount of processing required to analyse an update ought to be somehow correlated with the difficulty of this update. Thus, a necessary (but not sufficient) condition for realizing a real-time parsing system as suggested above is an interactive and incremental parsing system. The goal of this paper is to develop a basic machinery for incremental chart parsing and to outline how this could be embedded in an interactive parsing system.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Problem",
                "sec_num": "1.1"
            },
            {
                "text": "The word \"incremental ~ has been used in two differing senses in the (parsing) literature. The first sense stresses that input should be analysed in a piecemeal fashion, for example Bobrow and Webber (1980) , Mellish (1985) , Pulman (1085 Pulman ( , 1987 , Hirst (1987) , Haddock (1987) . According to this view, an incremental parser constructs the analysis of an utterance bit by bit (typically from left to right), rather than in one go when it has come to an end.",
                "cite_spans": [
                    {
                        "start": 182,
                        "end": 206,
                        "text": "Bobrow and Webber (1980)",
                        "ref_id": null
                    },
                    {
                        "start": 209,
                        "end": 223,
                        "text": "Mellish (1985)",
                        "ref_id": null
                    },
                    {
                        "start": 226,
                        "end": 238,
                        "text": "Pulman (1085",
                        "ref_id": null
                    },
                    {
                        "start": 239,
                        "end": 254,
                        "text": "Pulman ( , 1987",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 257,
                        "end": 269,
                        "text": "Hirst (1987)",
                        "ref_id": "BIBREF9"
                    },
                    {
                        "start": 272,
                        "end": 286,
                        "text": "Haddock (1987)",
                        "ref_id": "BIBREF8"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Parsing",
                "sec_num": "1.2"
            },
            {
                "text": "The other sense of \"incremental\" stresses the necessity of e~ciently handling arbitrary changes within current input. Thus, according to this view, an incremental parser should be able to efficiently handle not only piecemeal additions to a sentence, but, more generally, arbitrary insertions and deletions in it. This view of incremental parsing is typical of research on interactive programming environments, e.g. Lindstrom (1970) , Earley and Caisergues (1972) , Mandrioli (1979, 1980) , Reps and Teitelbaum (1987) . As indicated above, we are here interested in the latter view, which we summarize in the following working definition.",
                "cite_spans": [
                    {
                        "start": 416,
                        "end": 432,
                        "text": "Lindstrom (1970)",
                        "ref_id": "BIBREF12"
                    },
                    {
                        "start": 435,
                        "end": 463,
                        "text": "Earley and Caisergues (1972)",
                        "ref_id": null
                    },
                    {
                        "start": 466,
                        "end": 488,
                        "text": "Mandrioli (1979, 1980)",
                        "ref_id": null
                    },
                    {
                        "start": 491,
                        "end": 517,
                        "text": "Reps and Teitelbaum (1987)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Parsing",
                "sec_num": "1.2"
            },
            {
                "text": "Incremental parser. A parser capable of handling changes of previous input while expending an amount of effort which is proportional to the complexity of the changes. 1",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Parsing",
                "sec_num": "1.2"
            },
            {
                "text": "It should be pointed out that we are here limiting ourselves to a machinery for incremental parsing as opposed to incremental interpretation. In other words, the derivation of an utterance here takes into account only %ontext-free\" (lexical, syntactic, compositional-semantic) information obtained from grammar and dictionary. Nevertheless, I believe that this framework may be of some value also when approaching the more difficult problem of incremental interpretation.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Parsing",
                "sec_num": "1.2"
            },
            {
                "text": "We adopt the following working definition.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "Interactive parser. (Synonym: on-line parser.) A parser which monitors a text-input process, starting to parse immediately at the onset of new input, thereby achieving enhanced efficiency as well as a potential for dynamic improvement of its performance, for example by promptly reporting errors, asking for clarifications, etc. 2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "Within the area of programming environments, (generators for) language-based editors have been developed that make use of interactive (and incre-mental} parsing and compilation to perform program analysis, to report errors, and to generate code while the program is being edited, for example Mentor, Gandalf, and the Synthesizer Generator (Reps and Teitelbanm 1987) .",
                "cite_spans": [
                    {
                        "start": 339,
                        "end": 365,
                        "text": "(Reps and Teitelbanm 1987)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "Within natural-language processing, Tomita (1985) and Yonezawa and Ohsawa (1988) have reported parsers which operate on-line, but, incidentally, not incrementally in the sense adopted here. 3",
                "cite_spans": [
                    {
                        "start": 36,
                        "end": 49,
                        "text": "Tomita (1985)",
                        "ref_id": "BIBREF22"
                    },
                    {
                        "start": 54,
                        "end": 80,
                        "text": "Yonezawa and Ohsawa (1988)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "IThis definition is formed partly in analogy with a definition of \"incremental compilation\" by Earley and Caizergues (1972:1040) . We use \"complexity\" instead of \"size\" because different updates of the same size may cause differing processing efforts depending on the degree of grammatical complexity (ambiguity, context-sensitiveness) constraining the updates in question.",
                "cite_spans": [
                    {
                        "start": 95,
                        "end": 105,
                        "text": "Earley and",
                        "ref_id": null
                    },
                    {
                        "start": 106,
                        "end": 128,
                        "text": "Caizergues (1972:1040)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "21ncidentally, interactive parsing could be seen as one example of a general trend towards imrnatiate computation (Reps and Teitelbaum 1987:31) , also manifest in applications such as WYSIWYG word processing and spreadsheet programs, and sparked off by the availability of personal workstations with dedicated processors.",
                "cite_spans": [
                    {
                        "start": 114,
                        "end": 143,
                        "text": "(Reps and Teitelbaum 1987:31)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "SThe user may delete input from right to left, causing the systems to Uunparsen this input. This means that if the user wants to update some small fragment in the beginning of a sentence, the system has to reparse exhaustively from this update and on. (Of course, in reality the user has to first backspace and then retype everything from the change.)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "1.3"
            },
            {
                "text": "Section 2 presents an algorithm for incremental chart parsing. Section 3 discusses some additional aspects and alternative strategies. Section 4 gives a brief outline of the combined interactive and incremental parsing system, and section 5 summarizes the conclusions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Outline of Paper",
                "sec_num": "1.4"
            },
            {
                "text": "The incremental parser has been grounded in a chart-parsing framework (Kay 1980 , Thompson 1981 , Thompson and Ritchie 1984 for the following reasons:",
                "cite_spans": [
                    {
                        "start": 70,
                        "end": 79,
                        "text": "(Kay 1980",
                        "ref_id": "BIBREF10"
                    },
                    {
                        "start": 80,
                        "end": 95,
                        "text": ", Thompson 1981",
                        "ref_id": "BIBREF20"
                    },
                    {
                        "start": 96,
                        "end": 123,
                        "text": ", Thompson and Ritchie 1984",
                        "ref_id": "BIBREF21"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Chart Parsing",
                "sec_num": "2.1"
            },
            {
                "text": "\u2022 chart parsing is an efficient, open-ended, well understood, and frequently adopted technique in natural-language processing;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Chart Parsing",
                "sec_num": "2.1"
            },
            {
                "text": "\u2022 chart parsing gives us a previously unexplored possibility of embedding incrementality at a low cost.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Chart Parsing",
                "sec_num": "2.1"
            },
            {
                "text": "The idea of incremental chart parsing, as put forward here, is based on the following observation: The chart, while constituting a record of partial analyses (chart edges), may easily be provided with information also about the dependencies between those analyses. This is just what we need in incremental parsing since we want to propagate the effects of a change precisely to those parts of the previous analysis that, directly or indirectly, depend on the updated information.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Edge Dependencies",
                "sec_num": "2.2"
            },
            {
                "text": "In what ways could chart edges be said to depend on each other? Put simply, an edge depends upon another edge if it is formed using the latter edge. Thus, an edge formed through a prediction step depends on the (one) edge that triggered it. 4 Likewise, an edge formed through a combination 5 depends on the active-inactive edge pair that generated it. A scanned edge, on the other hand, does not depend upon any other edge, as scanning can be seen as a kind of initialization of the chart, e",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Edge Dependencies",
                "sec_num": "2.2"
            },
            {
                "text": "In order to account for edge dependencies we associate with each edge the set of its immediate source 4In the case of an initial top-down prediction, the source would be non-existent.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Edge Dependencies",
                "sec_num": "2.2"
            },
            {
                "text": "SThe ~raldeter operation in Earley (1970) ; the ~ndarnentad rule in Thompson (1981:2) . sit might be argued that a dependency should be established also in the case of an edge being proposed but rejected (owing to a redundancy test) because it already exists. However, as long as updates affect all preterminal edges extending from a vertex, this appears not to be crucial. edges (~back pointers\"). This information could be used to derive the corresponding sets of dependent edges (gforward pointers \") that we are interested in. For example, when a word in the previous input has been deleted, we want to remove all edges which depend on the preterminal (lexical) edge(s) corresponding to this word, as well as those preterminal edges themselves.",
                "cite_spans": [
                    {
                        "start": 28,
                        "end": 41,
                        "text": "Earley (1970)",
                        "ref_id": null
                    },
                    {
                        "start": 68,
                        "end": 85,
                        "text": "Thompson (1981:2)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Edge Dependencies",
                "sec_num": "2.2"
            },
            {
                "text": "Formally, let P be a binary dependency relation such that e P e ~ if and only if e t is a dependant of e, i.e., e' has been formed (directly) using e. If D* is the reflexive transitive closure of P, all edges e\" should be removed for which e D* e\" holds, i.e., all edges which directly or indirectly depend on e, as well as e itself. In addition, we are going to make use of the transitive closure of D, D +.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Edge Dependencies",
                "sec_num": "2.2"
            },
            {
                "text": "The resulting style of incremental parsing resembles truth (or reason) maintenance, in particular ATMS (de Kleer 1986). A chart edge here corresponds to an ATMS node, a preterminal edge corresponds to an assurnption node, the immediate source information of an edge corresponds to a justification, the dependency relation D* provides information corresponding to ATMS labels, etc.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Edge Dependencies",
                "sec_num": "2.2"
            },
            {
                "text": "The chart is a directed graph. The nodes, or vertices, vl, ..., Vn+l correspond to the positions surrounding the words of an n-word sentence t01 .. \u2022 ton. A pair of vertices vl,vy may be connected by arcs, or edges, bearing information about (partially) analysed constituents between v~ and vy. We will take an edge to be a tuple",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Chart",
                "sec_num": "2.3.1"
            },
            {
                "text": "starting from vertex v~ and ending at vertex vt with dotted rule X0--* a.~/ a dag D (cf. section 2.3.3), and the set of immediately dependent edges, E. s",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "(s, t, X0 --* a.#, D, E)",
                "sec_num": null
            },
            {
                "text": "In order to lay the ground for easy splitting and joining of chart fragments, we will take a vertex to consist of three parts, (L, Aioop, R), left, middle, and right. L and R will have internal structure, so that the full vertex structure will come out like The left part, (Ain, Ii~), consists of the incoming active and inactive edges which will remain with the left portion of the chart when it is split due VA dotted rule Xo --* a.~ corresponds to an (active) X0 edge containing an analysis of constituent(s) a, requiring constituent(s) ~ in order to yield an inactive edge.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "(s, t, X0 --* a.#, D, E)",
                "sec_num": null
            },
            {
                "text": "Sin other words, the set E of an edge e consists of all edges el for which e P el holds.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "(s, t, X0 --* a.#, D, E)",
                "sec_num": null
            },
            {
                "text": "to some internal sentence-editing operation. Correspondingly, the right part, (Aost, Io,t) , consists of the outgoing active and inactive edges which will remain with the right portion of the chart. The middle part, Aioop, consists of the active looping edges which, depending on the rule-invocation strategy, should remain either with the left or the right portion of the chart (cf. section 3.1).",
                "cite_spans": [
                    {
                        "start": 78,
                        "end": 90,
                        "text": "(Aost, Io,t)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "(s, t, X0 --* a.#, D, E)",
                "sec_num": null
            },
            {
                "text": "We will make use of dots for qualifying within elements of tuples. For example, e.s will stand for the starting vertex of edge e. Likewise, vi.L will stand for the set of edges belonging to the left half of vertex number i, and vi.Ai~ will denote the set of its active incoming edges. In addition, we will use vi.Po~t as a shorthand for the set of inactive outgoing edges at vi which are also preterminal (lexical).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "(s, t, X0 --* a.#, D, E)",
                "sec_num": null
            },
            {
                "text": "In general, parsing could be seen as a mapping from a sentence to a structure representing the analysis of the sentence --in this case a chart. Incremental parsing requires a more complex mapping F(., ~, r, Co) ~ cl from an edit operation ~7, a pair of cursor positions ~;, a sequence of words r (empty in the case of deletion), and an initial chart Co to a new chart cl (and using a grammar and dictionary as usual).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Editing Operations",
                "sec_num": "2.3.2"
            },
            {
                "text": "We are going to assume three kinds of editing operation, insert, delete, and replace. Furthermore, we assume that every operation applies to a continuous sequence of words tot.., tot, each of which maps to one or several preterminal edges extending from vertices vt, \u2022 .., vr, respectively. \u00b0 Thus, ~ may here take the values insert, delete, or replace; ~ is a pair of positions l, r such that the sequence of positions l, ..., r map directly to vertices vi, ..., W, and r is the corresponding sequence of words wt... tot.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Editing Operations",
                "sec_num": "2.3.2"
            },
            {
                "text": "In addition, we will make use of the constant 6 = r -l + 1, denoting the number of words affected by the editing operation.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Editing Operations",
                "sec_num": "2.3.2"
            },
            {
                "text": "In the algorithm below, as well as in the actual implementation, we have adopted a unification-based grammatical formalism with a context-free base, PATR (Shieber et al. 1983 , Shieber 1986 , because this seems to be the best candidate for a lingua /ranca in current natural-language processing. However, this formalism here shows up only within the edges, where we have an extra dag element (D), and when referring to rules, each of which consists of a \u00b0Character editing is processed by the scanner; cf. section 3.3. pair IX0 ~ ~, D) of a production and a dag. In the dag representation of the rule, we will store the context-free base under cat features as usual. We assume that the grammar is cycle-free. hence, it should be repeated for each such operation. The underlying chart parser specified in the end of section 2.4.2 makes use of a bottom-up ruleinvocation strategy. Top-clown rule invocation will be discussed in section 3.1.",
                "cite_spans": [
                    {
                        "start": 154,
                        "end": 174,
                        "text": "(Shieber et al. 1983",
                        "ref_id": null
                    },
                    {
                        "start": 175,
                        "end": 189,
                        "text": ", Shieber 1986",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Grammatical Formalism",
                "sec_num": null
            },
            {
                "text": "Input: An edit operation ~7, a pair of vertex numbers l, r, a sequence of words tot ..-t0r, and a chart co. We assume that chart co consists of vertices ul, ..., v~a,t, where last ~_ 1. We furthermore assume the constant 6 = r -l + 1 to be available.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Chart-Parsing Algorithm",
                "sec_num": "2.4.2"
            },
            {
                "text": "Output: A chart cl.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Chart-Parsing Algorithm",
                "sec_num": "2.4.2"
            },
            {
                "text": "Method: On the basis of the input, select and execute the appropriate update routine below. RunChart.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Chart-Parsing Algorithm",
                "sec_num": "2.4.2"
            },
            {
                "text": "This case occurs when 6 words wt\"\" tv~ have been inserted at the right end of previous input (i.e., l = last). This is the special case corresponding to ordinary left-to-right chart parsing, causing the original chart co to be extended 6 steps to the right.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Incremental Chart-Parsing Algorithm",
                "sec_num": "2.4.2"
            },
            {
                "text": "Deletion at right end of co fori :--l, ..., rdo Ve: e E vi.Po~t RemoveEdgesInD* (e); last := last-6. This case occurs when 5 words w~... t0r have been deleted up to and including the right end of previous input (i.e., r = last -1). It is handled by removing the preterminal edges corresponding to the deleted words along with all their dependent edges.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deletel:",
                "sec_num": null
            },
            {
                "text": "Deletion before right end of co for i :-l, ..., r do Ve: e E ~.Po~t RemoveEdgesInD*(e); MoveVertex/RightHalf(r + 1, l, -5); fori :--l+lto last-6 do MoveVertex (i + 5, i, -5); last := last-5;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Delete2:",
                "sec_num": null
            },
            {
                "text": "RunChart.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Delete2:",
                "sec_num": null
            },
            {
                "text": "This case occurs when 6 words wt\". wr have been deleted in an interval within or at the left end of previous input (i.e., r < last -1). It is handled by removing the preterminal edges corresponding to the deleted words along with all their dependent edges, and then collapsing the chart, moving all edges from vertex vr+l and on 6 steps to the left.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Delete2:",
                "sec_num": null
            },
            {
                "text": "Insertion before right end of co RemoveCrossingEdges (l); for i := last downto l + 1 do MoveVertex(i, i + 5, 5); MoveVertex/RightHalf(l, r + 1, 6); for i := l, ..., r do Scan(t0t); last := last -{-5; RunChart.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Insert2:",
                "sec_num": null
            },
            {
                "text": "This case occurs when 6 words wt-'. wr have been inserted at a position within or at the left end of previous input (i.e., I < last). It is handled by first removing all edges that %ross ~ vertex v~ (the vertex at which the new insertion is about to start). Secondly, the chart is split at vertex vl by moving all edges extending from this vertex or some vertex to the right of it 5 steps to the right. Finally, the new input is scanned and the resulting edges inserted into the chart. This case occurs when 8 words wt-.. Wr have been replaced by 6 other words at the corresponding positions within previous input (i.e., 1 ~_ I and r ~_ last; typically I --r). It is handled by first removing the preterminal edges corresponding to the replaced words along with all their dependent edges, and then scan the new words and insert the resulting edges into the chart.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Insert2:",
                "sec_num": null
            },
            {
                "text": "Alternatively, we could of course realize replace through delete and insert, but having a dedicated replace operation is more efficient. The purpose of this routine, which is called from Insert2, is to remove all edges that %ross\" vertex vt where the new insertion is about to start. This can be done in different ways. The solution above makes use of dependency information, removing every edge which is a dependant of both some preterminal edge incident to the change vertex and some preterminal edge extending from it. tl Alternatively, one could simply remove every edge e whose left connection e.s < l and whose right connection e.t > l.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Insert2:",
                "sec_num": null
            },
            {
                "text": "l\u00b0It may sometimes be the case that not all edges in the dependency closure need to be removed because, in the course of updating, some edge receives the same value as previously. This happens for example if a word is replaced by itself, or, given a grammar with atomic categories, if (say) a noun is replaced by another noun. One could reformulate the routines in such a way that they check for thiJ before removing an edge. 11For simplicity, we presuppo~ that preterminal edges only extend between adjacent vertices.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Insert2:",
                "sec_num": null
            },
            {
                "text": "If wl = a, then, for all lexical entries of the form (Xo--,a,D), add the edge (i,i+ 1, X0--, a., D, \u00a2).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 53,
                        "end": 92,
                        "text": "(Xo--,a,D), add the edge (i,i+ 1, X0--,",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Scan(~):",
                "sec_num": null
            },
            {
                "text": "Informally, this means adding an inactive, preterminal edge for each word sense of the word.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Scan(~):",
                "sec_num": null
            },
            {
                "text": "For each vertex v~, do the following two steps until no more edges can be added to the chart. {e, e'}) if the unification succeeds and this edge is not subsumed by another edge. Informally, this means forming a new edge whenever the category of the first needed constituent of an active edge matches the category of an inactive edge, 13 and the dag of the inactive edge can be unified in with the dag of the needed constituent.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "RunChart:",
                "sec_num": null
            },
            {
                "text": "The algorithm given in section 2.4.2 could be modified to top-down parsing by changing the predictor (see e.g. Wirdn 1988) and by having Move-Vertex/RightHalf not move active looping edges (vt.AIooo) since, in top-clown, these \"belong\" to the left portion of the chart where the predictions of them were generated. In general, the algorithm works better bottom-up than top-down because bottom-up predictions are 12One edge subsumes another edge if and only if the first three elements of the edges are identical and the fourth element of the first edge subsumes that of the second edge. For a definition of subsumption, see Shieber (1986:14) .",
                "cite_spans": [
                    {
                        "start": 624,
                        "end": 641,
                        "text": "Shieber (1986:14)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Top-Down Parsing",
                "sec_num": "3.1"
            },
            {
                "text": "lSNote that this condition is tested by the unification which specifically ensures that D( (Xm cat}) = E( (Yo eat}).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Top-Down Parsing",
                "sec_num": "3.1"
            },
            {
                "text": "made \"locally ~ at the starting vertex of the triggering (inactive) edge in question. Therefore, a changed preterminal edge will typically have its dependants locally, and, as a consequence, the whole update can be kept local. In top-down parsing, on the other hand, predictions are Uforward-directed', being made at the ending vertex of the triggering (active) edge. As a result of this, an update will, in particular, cause all predicted and combined edges after the change to be removed. The reason for this is that we have forward-directed predictions having generated active and inactive edges, the former of which in turn have generated forward-directed predictions, and so on through the chart. On the one hand, one might accept this, arguing that this is simply the way top-down works: It generates forward-directed hypotheses based on the preceding context, and if we change the preceding context, the forward hypotheses should change as well. Also, it is still slightly more well-behaved than exhaustive reanalysis from the change.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Top-Down Parsing",
                "sec_num": "3.1"
            },
            {
                "text": "On the other hand, the point of incremental parsing is to keep updates local, and if we want to take this seriously, it seems like a waste to destroy possibly usable structure to the right of the change. For example, in changing the sentence \"Sarah gave Kim a green apple s to \"Sarah gave a green apple to Kim s, there is no need for the phrase \"a green apple s to be reanalysed.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Top-Down Parsing",
                "sec_num": "3.1"
            },
            {
                "text": "One approach to this problem would be for the edge-removal process to introduce a \"cut s whenever a top-down prediction having some dependant edge is encountered, mark it as \"uncertain ~, and repeatedly, at some later points in time, try to find a new source for it. Eventually, if such a source cannot be found, the edge (along with dependants) should be Ugarbage-collected ~ because there is no way for the normal update machinery to remove an edge without a source (except for preterminal edges).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Top-Down Parsing",
                "sec_num": "3.1"
            },
            {
                "text": "In sum, it would be desirable if we were able to retain the open-endedness of chart parsing also with respect to rule invocation while still providing for efficient incremental update. However, the precise strategy for best achieving this remains to be worked out (also in the light of a fully testable interactive system}.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Top-Down Parsing",
                "sec_num": "3.1"
            },
            {
                "text": "Affected Edges",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Alternative Ways of Determining",
                "sec_num": "3.2"
            },
            {
                "text": "Henry Thompson (personal communication 1988) has pointed out that, instead of computing sets of dependants from source edges, it might suffice to simply record the latter, provided that the frequency of updates is small and the total number of edges is not too large. The idea is to sweep the whole edge space each time there is an update, repeatedly deleting anything with a non-existent source edge, and iterating until one gets through a whole pass with no new deletions.",
                "cite_spans": [
                    {
                        "start": 6,
                        "end": 44,
                        "text": "Thompson (personal communication 1988)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Maintain Sources Only",
                "sec_num": "3.2.1"
            },
            {
                "text": "If we confine ourselves to bottom-up parsing, and if we accept that an update will unconditionally cause all edges in the dependency closure to be removed (not allowing the kind of refinements discussed in footnote 10, it is in fact not necessary to record sources or dependencies at all. The reason for this is that, in effect, removing all dependants of all preterminal edges extending between vertices v|, ..., Vr+l in the bottom-up case amounts to removing all edges that extend somewhere within this interval (except for bottom-up predictions at vertex W+l which are triggered by edges outside of the interval). Given a suitable matrix representation for the chart (where edges are simultaneously indexed with respect to starting and ending vertices}, this may provide for a very efficient solution.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Maintain Neither Sources Nor Dependencies",
                "sec_num": "3.2.2"
            },
            {
                "text": "There is a trade-off between updating as local a unit as possible and the complexity of the algorithm for doing so. Given a complex-feature-based formalism like PATR, one extreme would be to maintain dependencies between feature instances of the chart instead of between chart edges. In principle, this is the approach of the Synthesizer Generator (Reps and Teitelbaum 1987) , which adopts attribute grammar for the language specification and maintains dependencies between the attribute instances of the derivation tree.",
                "cite_spans": [
                    {
                        "start": 348,
                        "end": 374,
                        "text": "(Reps and Teitelbaum 1987)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Maintain Dependencies between Features",
                "sec_num": "3.2.3"
            },
            {
                "text": "An approach to the lexical component which seems particularly suitable with respect to this type of parser, and which is adopted in the actual implementation, is the letter-tree format. 14 This approach takes advantage of the fact that words normally are entered from left to right, and supports the idea of a dynamic pointer which follows branches of the tree as a word is entered, immediately calling for reaction when an illegal string is detected. In particular, this allows you to distinguish an incomplete word from a (definitely) illegal word. Another advantage of this approach is that one may easily add two-level morphology (Koskenniemi 1983) as an additional filter. A radical approach, not pursued here, would be to employ the same type of incremental chart-parsing machinery at the lexical level as we do at the sentence level.",
                "cite_spans": [
                    {
                        "start": 634,
                        "end": 652,
                        "text": "(Koskenniemi 1983)",
                        "ref_id": "BIBREF11"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Lexical Component",
                "sec_num": "3.3"
            },
            {
                "text": "Incremental parsing would be even more beneficial if it were extended to handle dependencies across multiple sentences, for example with respect to nounphrases. Considering a language-sensitive text editor, the purpose of which would be to keep track of an input text, to detect (and maybe correct) certain linguistic errors, a change in one sentence often requires changes also in the surrounding text as in the following examples:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependencies across Sentences",
                "sec_num": "3.4"
            },
            {
                "text": "The house is full of mould. It has been judged insanitary by the public health committee. They say it has to be torn down.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependencies across Sentences",
                "sec_num": "3.4"
            },
            {
                "text": "The salmon jumped. It likes to play.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependencies across Sentences",
                "sec_num": "3.4"
            },
            {
                "text": "In the first example, changing the number of ~house ~ forces several grammatical changes in the subsequent sentences, requiring reanalysis. In the second example, changing \"it (likes) ~ to ~they (like) ~ constrains the noun-phrase of the previous sentence to be interpreted as plural, which could be reflected for example by putting the edges of the singular analysis to sleep.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependencies across Sentences",
                "sec_num": "3.4"
            },
            {
                "text": "Cross-sentence dependencies require a level of incremental interpretation and a database with nonmonotonic reasoning capabilities. For a recent approach in this direction, see Zernik and Brown (1988) .",
                "cite_spans": [
                    {
                        "start": 176,
                        "end": 199,
                        "text": "Zernik and Brown (1988)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Dependencies across Sentences",
                "sec_num": "3.4"
            },
            {
                "text": "Scanner Incremental I Grammar chart parser Chart I Figure I . Main components of the LIPS system It is planned to maintain a dynamic agenda of update tasks (either at the level of update functions or, preferably, at the level of individual edges), removing tasks which are no longer needed because the user has made them obsolete (for example by immediately deleting an inserted text).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 51,
                        "end": 59,
                        "text": "Figure I",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Text editor I Lexicon",
                "sec_num": null
            },
            {
                "text": "In the long run, an interactive parsing system probably has to have some built-in notion of time, for example through time-stamped editing operations and (adjustable) strategies for timing of update operations.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Text editor I Lexicon",
                "sec_num": null
            },
            {
                "text": "This paper has demonstrated how a chart parser by simple means could be augmented to perform incremental parsing, and has suggested how this system in turn could be embedded in an interactive parsing system. Incrementality and interactivity are two independent properties, but, in practice, an incremental system that is not interactive would be pointless, and an interactive system that is not incremental would at least be less efficient than it could be. Although exhaustive recomputation can be fast enough for small problems, incrementality is ultimately needed in order to cope with longer and more complex texts. In addition, incremental parsing brings to the system a certain ~naturainess ~ analyses are put together piece by piece, and there is a built-in correlation between the amount of proceasing required for a task and its difficulty.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "5"
            },
            {
                "text": "\"Easy things should be easy... ~ (Alan Kay).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "5"
            },
            {
                "text": "This section outlines how the incremental parser is embedded in an interactive parsing system, called LIPS. 15 Figure 1 shows the main components of the system. The user types a sentence into the editor (a Xerox TEDIT text editor). The words are analysed on-line by the scanner and handed over to the parser proper which keeps the chart consistent with the input sentence. Unknown words are marked as illegal in the edit window. The system displays the chart incrementally, drawing and erasing individual edges in tandem with the parsing process.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 111,
                        "end": 119,
                        "text": "Figure 1",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "4"
            },
            {
                "text": "lSLink~iping Interactive Parsing System.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Interactive Parsing",
                "sec_num": "4"
            },
            {
                "text": "Tr/e according to the terminology ofAho, Hopcroft, and Ullman (1987:163).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            }
        ],
        "back_matter": [],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "Data Structures and Algorithms",
                "authors": [
                    {
                        "first": "Alfred",
                        "middle": [
                            "V"
                        ],
                        "last": "Aho",
                        "suffix": ""
                    },
                    {
                        "first": "E",
                        "middle": [],
                        "last": "John",
                        "suffix": ""
                    },
                    {
                        "first": "Jeffrey",
                        "middle": [
                            "D"
                        ],
                        "last": "Hopcroft",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Ullman",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Aho, Alfred V., John E. Hopcroft, and Jeffrey D. Ullman (1987). Data Structures and Algorithms. Addison-Wesley, Reading, Massachusetts.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "Knowledge Representation for Syntactic/Semantic Processing",
                "authors": [],
                "year": null,
                "venue": "Proc. First Annual National Conference on Artificial Intelligence",
                "volume": "",
                "issue": "",
                "pages": "316--323",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Knowledge Representation for Syntactic/Semantic Processing. Proc. First Annual National Conference on Artificial Intelligence, Stanford, California: 316- 323.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "An Assumption-based TMS",
                "authors": [
                    {
                        "first": "Johan",
                        "middle": [],
                        "last": "De Kleer",
                        "suffix": ""
                    }
                ],
                "year": 1986,
                "venue": "Artificial Intelligence",
                "volume": "28",
                "issue": "2",
                "pages": "127--162",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "de Kleer, Johan (1986). An Assumption-based TMS. Artificial Intelligence 28(2):127-162.",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "A Method for Incrementally Compiling Languages with Nested Statement Structure",
                "authors": [
                    {
                        "first": "Jay",
                        "middle": [],
                        "last": "Earley",
                        "suffix": ""
                    },
                    {
                        "first": "Paul",
                        "middle": [],
                        "last": "Caizergues",
                        "suffix": ""
                    }
                ],
                "year": 1972,
                "venue": "Communications of the ACM",
                "volume": "15",
                "issue": "12",
                "pages": "1040--1044",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Earley, Jay and Paul Caizergues (1972). A Method for Incrementally Compiling Languages with Nested Statement Structure. Communications of the ACM 15(12):1040-1044.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "Incremental Parsing",
                "authors": [
                    {
                        "first": "Carlo",
                        "middle": [],
                        "last": "Ghezzi",
                        "suffix": ""
                    },
                    {
                        "first": "Dino",
                        "middle": [],
                        "last": "Mandrioli",
                        "suffix": ""
                    }
                ],
                "year": 1979,
                "venue": "ACM Transactions on Programming Languages and Systems",
                "volume": "1",
                "issue": "1",
                "pages": "58--70",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ghezzi, Carlo and Dino Mandrioli (1979). Incremen- tal Parsing. ACM Transactions on Programming Languages and Systems 1(1):58-70.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "Augmenting Parsers to Support Incrementality",
                "authors": [
                    {
                        "first": "Carlo",
                        "middle": [],
                        "last": "Ghezzi",
                        "suffix": ""
                    },
                    {
                        "first": "Dino",
                        "middle": [],
                        "last": "Mandrioli",
                        "suffix": ""
                    }
                ],
                "year": 1980,
                "venue": "Journal of the Association for Computing Machinery",
                "volume": "27",
                "issue": "3",
                "pages": "564--579",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ghezzi, Carlo and Dino Mandrioli (1980). Aug- menting Parsers to Support Incrementality. Jour- nal of the Association for Computing Machinery 27(3):564-579.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "Incremental Interpretation and Combinatory Categorial Grammar",
                "authors": [
                    {
                        "first": "Nicholas",
                        "middle": [
                            "J"
                        ],
                        "last": "Haddock",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "Proc. Tenth International Joint Conference on Artificial Intelligence",
                "volume": "",
                "issue": "",
                "pages": "661--663",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Haddock, Nicholas J. (1987). Incremental Interpre- tation and Combinatory Categorial Grammar. Proc. Tenth International Joint Conference on Artificial Intelligence, Milan, Italy: 661-663.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "Semantic Interpretation and the Resolution of Ambiguity",
                "authors": [
                    {
                        "first": "Graeme",
                        "middle": [],
                        "last": "Hirst",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Hirst, Graeme (1987). Semantic Interpretation and the Resolution of Ambiguity. Cambridge University Press, Cambridge, England.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "Algorithm Schemata and Data Structures in Syntactic Processing",
                "authors": [
                    {
                        "first": "Martin",
                        "middle": [],
                        "last": "Kay",
                        "suffix": ""
                    }
                ],
                "year": 1980,
                "venue": "Tezt Processing. Proceedings of Nobel Symposium 51",
                "volume": "",
                "issue": "",
                "pages": "327--358",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kay, Martin (1980). Algorithm Schemata and Data Structures in Syntactic Processing. Report CSL-80- 12, Xerox PARC, Palo Alto, California. Also in: Sture Alldn, ed. (1982), Tezt Processing. Proceed- ings of Nobel Symposium 51. Almqvist & Wiksell International, Stockholm, Sweden: 327-358.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "Two-Level Morphology: A General Computational Model for Word-Form Recognition and Production",
                "authors": [
                    {
                        "first": "Kimmo",
                        "middle": [],
                        "last": "Koskenniemi",
                        "suffix": ""
                    }
                ],
                "year": 1983,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Koskenniemi, Kimmo (1983). Two-Level Morphol- ogy: A General Computational Model for Word- Form Recognition and Production. Publication No. 11, Department of General Linguistics, University of Helsinki, Helsinki, Finland.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "The Design of Parsers for Incremental Language Processors",
                "authors": [
                    {
                        "first": "G",
                        "middle": [],
                        "last": "Lindstrom",
                        "suffix": ""
                    }
                ],
                "year": 1970,
                "venue": "Proc. Pad ACM Symposium on Theory of Computing",
                "volume": "",
                "issue": "",
                "pages": "81--91",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Lindstrom, G. (1970). The Design of Parsers for Incremental Language Processors. Proc. Pad ACM Symposium on Theory of Computing, Northampton, Massachusetts: 81-91.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "Computer Interpretation of Natural Language Descriptions",
                "authors": [
                    {
                        "first": "Christopher",
                        "middle": [
                            "S"
                        ],
                        "last": "Melllsh",
                        "suffix": ""
                    }
                ],
                "year": 1985,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Melllsh, Christopher S. (1985). Computer Interpre- tation of Natural Language Descriptions. Ellis Hor- wood, Chichester, England.",
                "links": null
            },
            "BIBREF14": {
                "ref_id": "b14",
                "title": "A Parser That Doesn't",
                "authors": [
                    {
                        "first": "Steven",
                        "middle": [
                            "G"
                        ],
                        "last": "Pulman",
                        "suffix": ""
                    }
                ],
                "year": 1985,
                "venue": "Proc. Second Conference of the European Chapter",
                "volume": "",
                "issue": "",
                "pages": "128--135",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Pulman, Steven G. (1985). A Parser That Doesn't. Proc. Second Conference of the European Chapter of the Association for Computational Linguistics, Geneva, Switzerland: 128-135.",
                "links": null
            },
            "BIBREF15": {
                "ref_id": "b15",
                "title": "The Syntax-Semantics Interface",
                "authors": [
                    {
                        "first": "Steven",
                        "middle": [
                            "G"
                        ],
                        "last": "Pulman",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "Linguistic Theory and Computer Applications",
                "volume": "",
                "issue": "",
                "pages": "189--224",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Pulman, Steven G. (1987). The Syntax-Semantics Interface. In: Pete Whitelock, Mary McGee Wood, Harold Somers, Rod Johnson, and Paul Bennett, ed., Linguistic Theory and Computer Applications. Aca- demic Press, London, England: 189-224.",
                "links": null
            },
            "BIBREF16": {
                "ref_id": "b16",
                "title": "Language Processing in Program Editors",
                "authors": [
                    {
                        "first": "Thomas",
                        "middle": [],
                        "last": "Reps",
                        "suffix": ""
                    },
                    {
                        "first": "Tim",
                        "middle": [],
                        "last": "Teitelbanm",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "Computer",
                "volume": "20",
                "issue": "11",
                "pages": "29--40",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Reps, Thomas and Tim Teitelbanm (1987). Lan- guage Processing in Program Editors. Computer 20(11):29-40.",
                "links": null
            },
            "BIBREF17": {
                "ref_id": "b17",
                "title": "An Introduction to Unification-Based Approaches to Grammar",
                "authors": [
                    {
                        "first": "Stuart",
                        "middle": [
                            "M"
                        ],
                        "last": "Shleber",
                        "suffix": ""
                    }
                ],
                "year": 1986,
                "venue": "CSLI Lecture Notes",
                "volume": "",
                "issue": "4",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Shleber, Stuart M. (1986). An Introduction to Unification-Based Approaches to Grammar. CSLI Lecture Notes No. 4. University of Chicago Press, Chicago, Illinois.",
                "links": null
            },
            "BIBREF19": {
                "ref_id": "b19",
                "title": "The Formalism and Implementation of PATR-II",
                "authors": [],
                "year": null,
                "venue": "Research on Interactive Acquisition and Use of Knowledge. SRI Final Report 1894, SRI International",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "The Formalism and Implementation of PATR-II. In: Barbara Grosz and Mark Stickel, eds., Research on Interactive Acquisition and Use of Knowledge. SRI Final Report 1894, SRI International, Menlo Park, California.",
                "links": null
            },
            "BIBREF20": {
                "ref_id": "b20",
                "title": "Chart Parsing and Rule Schemata in GPSG",
                "authors": [
                    {
                        "first": "Henry",
                        "middle": [],
                        "last": "Thompson",
                        "suffix": ""
                    }
                ],
                "year": 1981,
                "venue": "Proc. 19th Annual Meeting of the Association for Computational Linguistics",
                "volume": "165",
                "issue": "",
                "pages": "167--172",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Thompson, Henry (1981). Chart Parsing and Rule Schemata in GPSG. Research Paper No. 165, De- partment of Artificial Intelligence, University of Ed- inburgh, Edinburgh, Scotland. Also in: Proc. 19th Annual Meeting of the Association for Computa- tional Linguistics, Stanford, California: 167-172.",
                "links": null
            },
            "BIBREF21": {
                "ref_id": "b21",
                "title": "Implementing Natural Language Parsers",
                "authors": [
                    {
                        "first": "Henry",
                        "middle": [],
                        "last": "Thompson",
                        "suffix": ""
                    },
                    {
                        "first": "Grasme",
                        "middle": [],
                        "last": "Ritchie",
                        "suffix": ""
                    }
                ],
                "year": 1984,
                "venue": "Artificial Intelligence: Tools, Techniques, and Applications. Harper & Row",
                "volume": "",
                "issue": "",
                "pages": "245--300",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Thompson, Henry and Grasme Ritchie (1984). Im- plementing Natural Language Parsers. In: Tim O'Shea and Marc Eisenstadt, Artificial Intelligence: Tools, Techniques, and Applications. Harper & Row, New York, New York: 245-300.",
                "links": null
            },
            "BIBREF22": {
                "ref_id": "b22",
                "title": "An Efficient Context-Free Parsing Algorithm for Natural Languages",
                "authors": [
                    {
                        "first": "Masaru",
                        "middle": [],
                        "last": "Tomita",
                        "suffix": ""
                    }
                ],
                "year": 1985,
                "venue": "Proc. Ninth International Joint Conference on Artificial Intelligence",
                "volume": "",
                "issue": "",
                "pages": "756--764",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Tomita, Masaru (1985). An Efficient Context-Free Parsing Algorithm for Natural Languages. Proc. Ninth International Joint Conference on Artificial Intelligence, Los Angeles, California: 756--764.",
                "links": null
            },
            "BIBREF24": {
                "ref_id": "b24",
                "title": "Object-Oriented Parallel Parsing for Context-Free Grammars",
                "authors": [],
                "year": null,
                "venue": "Proc. ll~th International Conference on Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "773--778",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Object-Oriented Parallel Parsing for Context-Free Grammars. Proc. ll~th International Conference on Computational Linguistics, Budapest, Hungary: 773-778.",
                "links": null
            },
            "BIBREF25": {
                "ref_id": "b25",
                "title": "A Control-Strategy-Independent Parser for PATR",
                "authors": [
                    {
                        "first": "Mats",
                        "middle": [],
                        "last": "Wires",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "Proc. First Scandinavian Conference on Artificial Intelligence, Troms\u00a2, Norway: 161-172. Also research report LiTH",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Wires, Mats (1988). A Control-Strategy-Indepen- dent Parser for PATR. Proc. First Scandinavian Conference on Artificial Intelligence, Troms\u00a2, Nor- way: 161-172. Also research report LiTH-IDA-R- 88-10, Department of Computer and Information Science, Link~ping University, Link6ping, Sweden.",
                "links": null
            },
            "BIBREF26": {
                "ref_id": "b26",
                "title": "Default Reasoning in Natural Language Processing",
                "authors": [
                    {
                        "first": "Uri",
                        "middle": [],
                        "last": "Zernlk",
                        "suffix": ""
                    },
                    {
                        "first": "Allen",
                        "middle": [],
                        "last": "Brown",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "Proc. ll~th International Conference on Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "801--805",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Zernlk, Uri and Allen Brown (1988). Default Rea- soning in Natural Language Processing. Proc. ll~th International Conference on Computational Linguis- tics, Budapest, Hungary: 801-805.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF0": {
                "uris": null,
                "type_str": "figure",
                "num": null,
                "text": "end of Co for i :--l, ..., r do Scan(w~); last := last + 8;"
            },
            "FIGREF2": {
                "uris": null,
                "type_str": "figure",
                "num": null,
                "text": "all edges that are in the reflexive transitive dependency closure of a given edge e. 1\u00b0 MoveVertex(from, to, ~): t;to := V/rom; Ve: e E Vto.Atooo U Vto.R e.s := e.s + 6; e.t := e.t + 6. This routine moves the contents of a vertex from v#om to vto and assigns new connectivity information to the affected (outgoing) edges. Move Vertex /Righ tHalf(frora, to, 6): V~o.R := vlrora.R; Vto.Atoop := UHom.Atoop; v/rom.R := ~; vSrom.Atoop := ~; Ve: e E uto.Aiooo U Vto.R e.s := e.e + 6; e.t := e.t + 6. This routine moves the contents of the right half (including active looping edges) of a vertex from vy,o,n to vto and assigns new connectivity information to the affected (outgoing) edges."
            },
            "FIGREF3": {
                "uris": null,
                "type_str": "figure",
                "num": null,
                "text": "of the form (i, j, X0 --~ a., D, E) and each rule of the form (Y0 ~ Yx/~, D') such that D'((Y1 cat)) = D((Xo cat)), add an edge of the form (i, i, Yo --* .]/1/3, D', {e)) if this edge is not subsumed 1~ by another edge. Informally, this means predicting an edge according to each rule whose first righthand-side category matches the category of the inactive edge under consideration. 2. Combine: For each edge e of the form (i, 3\", Xo --* a.X,n~, D, E) and each edge e s of the form (3\", k, Yo --* ~/., D', El), add the edge (i, k, Xo ---, aX, n.~, D U [Xm: D'(Yo)],"
            }
        }
    }
}