| { | |
| "paper_id": "1993", | |
| "header": { | |
| "generated_with": "S2ORC 1.0.0", | |
| "date_generated": "2023-01-19T07:34:33.992977Z" | |
| }, | |
| "title": "Adventures in Multi-dimensional Parsing: Cycles and Disorders", | |
| "authors": [ | |
| { | |
| "first": "Kent", | |
| "middle": [], | |
| "last": "Wittenburg", | |
| "suffix": "", | |
| "affiliation": {}, | |
| "email": "" | |
| } | |
| ], | |
| "year": "", | |
| "venue": null, | |
| "identifiers": {}, | |
| "abstract": "Among the proposals for multidimensional grammars is a family of constraint-based gram matical frameworks, including Relational Grammars. In Relational languages, expressions are formally defined as a set of relations whose tuples are taken from an indexed set of symbols. Both bottom-up parsing and Earley-style parsing algorithms have previously been proposed for different classes of Relational languages. The Relational language class for Earley style parsing in Wittenburg (1992a} requires that each relation be a partial order. However, in some real-world domains, the relations do not naturally conform to these restrictions. In this paper I discuss motivations and methods for predictive, Earley-style parsing of multidimensional languages when the relations involved do not necessarily yield an ordering, e.g., when the relations are symmetric and /or nontransitive. The solution involves guaranteeing that a single initial start position for parsing can be associated with any member of the input set. The domains in which these issues are discussed involve incremental parsing in interfaces and off-line verification of multidimensional data.", | |
| "pdf_parse": { | |
| "paper_id": "1993", | |
| "_pdf_hash": "", | |
| "abstract": [ | |
| { | |
| "text": "Among the proposals for multidimensional grammars is a family of constraint-based gram matical frameworks, including Relational Grammars. In Relational languages, expressions are formally defined as a set of relations whose tuples are taken from an indexed set of symbols. Both bottom-up parsing and Earley-style parsing algorithms have previously been proposed for different classes of Relational languages. The Relational language class for Earley style parsing in Wittenburg (1992a} requires that each relation be a partial order. However, in some real-world domains, the relations do not naturally conform to these restrictions. In this paper I discuss motivations and methods for predictive, Earley-style parsing of multidimensional languages when the relations involved do not necessarily yield an ordering, e.g., when the relations are symmetric and /or nontransitive. The solution involves guaranteeing that a single initial start position for parsing can be associated with any member of the input set. The domains in which these issues are discussed involve incremental parsing in interfaces and off-line verification of multidimensional data.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Abstract", | |
| "sec_num": null | |
| } | |
| ], | |
| "body_text": [ | |
| { | |
| "text": "We itzman and Wittenburg, 1993) ", | |
| "cite_spans": [ | |
| { | |
| "start": 14, | |
| "end": 31, | |
| "text": "Wittenburg, 1993)", | |
| "ref_id": "BIBREF10" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "The limitations of these previously proposed al gorithms have become evident in two domains for Relational Grammars under current inves tigation: on-line incremental parsing of visual . language expressions", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Bellcore is summarized, followed by relevant as pects of Earley-style parsing from Wittenburg (1992a) . We then turn to the question of how to define a suitable subclass of Relational Grammars for ensuring that parsing may be initiated from an arbitrary starting point. An Earley-style pars ing algorithm and example trace are presented next. The conclusion includes remarks regarding the extensions to this work necessary to fully solve the problems of incremental, predictive parsing for higher-dimensional languages.", | |
| "cite_spans": [ | |
| { | |
| "start": 83, | |
| "end": 101, | |
| "text": "Wittenburg (1992a)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "The remainder of this paper is structured as .fol lows. First, as a review and refinement of work to date, a Relational Grammar formalism for prac tical applications developed and implemented at \u2022", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Relational Grammars are motivated by domains in which the sets of objects to be generated or analyzed can not comfortably be represented as strict linear orders of symbols. Examples include expressions in 2-D such as mathematics notation, flowcharts, or schematic diagrams; 2-D or 3-D graphical layouts and displays , perhaps with time or additional media as added dimensions; and n dimensional data to be found in empirical data collections or various types of databases. One must generalize the data type of language expres sions from, say, one-dimensional arrays (strings) to 2-, or perhaps n-dimensional arrays or, more generally, to graphs of relations where the nodes represent data in unrestricted formats. Notions of replacement in derivations have to be gener alized also, and, as attested by the literature on array and graph grammars, there are many varia tions on how to define grammar productions and the notion of replacement ( called the embedding problem in the graph-grammar literature).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A Relational Grammar Formalism", | |
| "sec_num": "2" | |
| }, | |
| { | |
| "text": "The Relational Language (RL) framework pro vides for an abstraction over the particular data structures used to hold the object sets being pro cessed. The grammar productions make mention of the relations expected to hold in the data but there is flexibility in choosing exactly how the data is represented and stored as well as the im plementation of how the relations are checked or queried. Such an approach accommodates many kinds of data representations, including array or graph structures, K-D trees, or even commercial databases in which indexings may be precisely tuned for efficiency.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A Relational Grammar Formalism", | |
| "sec_num": "2" | |
| }, | |
| { | |
| "text": "Combining input objects during the parsing process can be characterized neutrally through set operations -set union then being a very gen eral analog of string concatenation. It is natural to think of a grammar rule as providing a defini tion of a composite (nonterminal) object as a set (usually nonunary) whose type is the symbol on the left-hand-side of the rule and whose parts are the union of the parts of the objects whose types are the symbols on the right-hand-side of the rule. Derivations are defined as a sequence of replace ments that are headed by a type that is a root symbol of the grammar and terminate in a set of objects whose types are taken from the vocabu lary of terminal symbols. An important charac teristic of the RL approach is that derivations are trees, as is the case in conventional context-free grammars. An effect of this restriction is that no object may be used more than once per deriva tion.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A Relational Grammar Formalism", | |
| "sec_num": "2" | |
| }, | |
| { | |
| "text": "The most significant new requirement for the grammar formalism is that it has to provide a means for specifying possible combining relations explicitly. Specifying combining relations in Re-. lational Grammars is done by stating, for each el ement in the right-hand-side of a non-unary rule, what relation it has to stand in with respect to at least one other right-hand-side element. Oper ationally, a parser finds relevant input for combi-\u2022 nation by executing queries formed from the re lational constraints.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A Relational Grammar Formalism", | |
| "sec_num": "2" | |
| }, | |
| { | |
| "text": "Besides the unification-based approaches to Re lational Languages mentioned above, a more ef ficient grammar compiler has also been imple mented (Wittenburg, 1992b ) that incorporates a form of \"pseudo-unification\" (see To mita, 1990). One may consider the pseudo-unification-based formalism as syntactic sugar for an underlying unification system. From this point of view; the results of this paper generalize to the full fam ily of extended unification-based approaches and thus it is not the case that we are dealing here with yet another special-case grammar formalism. Nevertheless, we will use the pseudo-unification based formalism in this dicussion since it is less verbose than the full unification-based specifica tion. It also of course affords the possibility that specialized algorithms may be found that can be proved more efficient than general unification. ", | |
| "cite_spans": [ | |
| { | |
| "start": 145, | |
| "end": 163, | |
| "text": "(Wittenburg, 1992b", | |
| "ref_id": "BIBREF9" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A Relational Grammar Formalism", | |
| "sec_num": "2" | |
| }, | |
| { | |
| "text": "During parsing, relational constraints either have the effect of generating possible candidates for rule element matches or filtering candidate matches that have been proposed. Relational constraints immediately following the keyword :expanders act as a generators. These relations must be binary, and the parser will execute a query based on these relational expressions as it explores candidates to match rule elements. For example, the query {below :? i) would be exe cuted when matching rule Subtree-rule in order to expand the match to the second right-hand side element, assuming i is an index to the input matching the first right-hand-side element. We call the binary, generating relations expander re lations, since their main role is to expand rule matches. In addition, one may include further relational constraints {of any arity). These non initial constraints will be executed as predicates. In Example 1, (centered-in-x 12) is the only pred icate. Figure 1 shows a graphical depiction of the rule in Example 1 in which composition is repre sented as spatial enclosure. Thus one sees that the Subtree object is composed of the prim and' Row objects. The arrows represent the required spatial relations.", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 963, | |
| "end": 971, | |
| "text": "Figure 1", | |
| "ref_id": "FIGREF9" | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": ". n. The backbone of this rule thus could be written as Subtree --+ prim Row. A relational constraint such as {below 2 1) is to be interpreted as a requirement that the object matching rule element 2 {of type Row in this case) must stand in the below relation to the object matching rule element 1 {of type prim).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "centered-in- ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subtree strim)", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "+ below ( Row )", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subtree strim)", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "i < j.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subtree strim)", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "That is, considered as a graph with the ex pander relations as arcs, the right-hand-side of a rule must be connected and, when ordered, each element in turn must be connected to some other element earlier in the ordering. This requirement implies that this class of Relational Grammars can generate only connected relation graphs since, for every production, we assume that there is at least one ordering that meets this condition.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subtree strim)", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "In remaining examples in this section, we will as sume that the rules are ordered as shown, and we will associate the relational constraints with the relevant rule elements rather than list them at the end of the rule definition. Wittenburg (1992a) . The alternative is to write grammars that state relational constraints only on individu als in the input set and use feature percolation to pass up bindings of these individuals as attribute values in derivations. We will refer to this latter subclass of Relational Grammars as Atomic Re lational Grammars (ARGs), noting that the most significant restriction is that the arguments of re lational constraints must be atomic.", | |
| "cite_spans": [ | |
| { | |
| "start": 230, | |
| "end": 248, | |
| "text": "Wittenburg (1992a)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Since the expander constraints are going to pro vide the parser with a query function that can find the candidates to combine with next at each step, this restriction ensures that an expander query can fire at each stage in the rule match. Once an ordering is found, a grammar compiler can place an expander or predicate expression with the first rule element in which all the argu ments of the relational expression will be bound. 1", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "As an illustration, consider Example 2, the rule set of a flowchart grammar fragment. The root symbol for this grammar is Flowchart. ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Since the expander constraints are going to pro vide the parser with a query function that can find the candidates to combine with next at each step, this restriction ensures that an expander query can fire at each stage in the rule match. Once an ordering is found, a grammar compiler can place an expander or predicate expression with the first rule element in which all the argu ments of the relational expression will be bound. 1", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Restriction 2. Each production must percolate a value for every expander attribute used in the grammar. ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "We propose the following restriction for Atomic Relational Grammar productions, whose utility will become most evident when we consider predictive parsing later in this paper:", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "As suggested in the concluding remarks of Wittenburg (1992a) , there is still research to be done to minimize enumeration sequences further. In Wittenburg (1992a) Table 1 . To get an intuitive grasp of this relationship of percolation paths and pre diction, which will be carried over here, consider again the input in Figure 3 with the grammar in Example 2. Assume that an Earley-style parser has scanned the topmost oval, indexed as 1 in the figure. This would imply the existence of an item that incorporated a dotted production of rule Flowchart, repeated here. Note now that the expander constraint (connects-to 1 (in 2)) is of relevance in predict ing the next input to be scanned. Given just this item, only those input elements that are candi dates to bind the in attribute of a P-block con stituent need be considered. In particular, we need not consider ordering variants of P-block rules in which the initial right-hand-side element cannot serve to bind this attribute. These obser vations lead us to the following definition. The starts-by-binding relation forms the ba sis for precompiling a Prediction Table. A rule variant in the table indexed by some nontermi nal category X and some expander attribute attr implies that the production expands nonterminal X and that there is an assignment of the form (attr 0) = . . . 1 ... in the feature percolations of that production, i.e., the cover of the first right hand-side element grounds attr if it is a terminal or it carries an attribute whose value is linked to attr if it is a nonterminal.", | |
| "cite_spans": [ | |
| { | |
| "start": 42, | |
| "end": 60, | |
| "text": "Wittenburg (1992a)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 144, | |
| "end": 162, | |
| "text": "Wittenburg (1992a)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [ | |
| { | |
| "start": 163, | |
| "end": 170, | |
| "text": "Table 1", | |
| "ref_id": "TABREF3" | |
| }, | |
| { | |
| "start": 319, | |
| "end": 327, | |
| "text": "Figure 3", | |
| "ref_id": "FIGREF8" | |
| }, | |
| { | |
| "start": 1116, | |
| "end": 1122, | |
| "text": "Table.", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "The intuitive idea of the parsing algorithm is as follows. The parser is initialized in Earley style with dotted productions expanding root symbols of the grammar at each of the minimal elements of the input. Extended predict, scan, and complete steps carry over from Earley 's algorithm, so the parser will build up item sets through enumer ations of the nodes of the input relation graph originating at the minimal nodes. Note that no matter where the parser starts in the input, a suc cessful derivation starting from that position will have to visit all the nodes of the input graph at least once. The main goal in designing the algo rithm is to minimize the number of enumerations while still ensuring completeness. When two or more enumeration sequences converge, the algo rithm is able to detect when a prediction has been made before so that the same prediction ( and all items that ensue) don't have to be re-created. In order to be able to absorb the products of a previ ous prediction into a converging enumeration se quence, a fourth step has to be added to Earley's WITTENBURG predict, scan, and complete . It is called inverse complete . Where complete is given an inactive state and asked to extend active states that end where the inactive state starts, inverse-complete is given an active state and tries to extend it with any inactive states that start where the active state ends .", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "The derivation of a table representing this re lation is in two steps. We first generate rule or dering variants. Here we assume an algorithm that, for each production, forms one. ordering variant per right-hand-side element such that the right-hand-side element is ordered first. Ordering the remaining elements is done arbitrarily sub ject to the connectedness condition in Restriction 1. 3 Step two generates a table representing the starts-by-binding relation in the grammar and, in addition, we include in the table the special \"at tribute\" start, whose entry includes a set of rule variants such that for each production expand ing that nonterminal category, there is at least one variant ordering each right-hand-side element first, regardless of feature Table at nonterminal N an.cl attribute A. ", | |
| "cite_spans": [ | |
| { | |
| "start": 391, | |
| "end": 392, | |
| "text": "3", | |
| "ref_id": "BIBREF1" | |
| } | |
| ], | |
| "ref_spans": [ | |
| { | |
| "start": 398, | |
| "end": 768, | |
| "text": "two generates a table representing the starts-by-binding relation in the grammar and, in addition, we include in the table the special \"at tribute\" start, whose entry includes a set of rule variants such that for each production expand ing that nonterminal category, there is at least one variant ordering each right-hand-side element first, regardless of feature", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 769, | |
| "end": 777, | |
| "text": "Table at", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": ", the predict subrou tine makes use of the function F-permute to find all candidate rules for prediction. This function maps from an expander attribute and a predicted nonterminal to rule variants appropriately or dered that can expand that nonterminal. Appro priately ordered here implies that the production can provide a possible percolation path such that, as the left-branch of an eventual derivation sub tree bottoms out, terminal elements scanned at that position can ground the expander attribute used in prediction. Such a mapping is extracted from what was called an F-permute table, as ex emplified in", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "5 Earley-style fo r ARGs", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "For example, the first-attrs of ordered pro duction conditional-I is the set {in}. The first attrs of ordered production basic-p-block is the set {in out}. The first-attrs of a production are those expander attributes associated with the first rhs element of a production that provide bindings for expander attributes in the left-hand side. They are used in the recursive predict step of the Earley-style algorithm to follow.", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "which the starting position is arbitrary. We will summarize the essential points here, and confine our attention to a recognition algorithm. Inactive states will be indexed in the parse ta ble by every binding of an expander attribute in f (all of which must be individuals in C). In tuitively, we consider inactive states to begin as well as end at every terminal that is bound by an expander attribute. However, this parser doesn't make the distinction between beginning and end ing so we need only a single indexing array.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "We now turn to an Earley-style algorithm for the full class of Atomic Relational Grammars in", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "We next turn to active states, which represent partially matched or unmatched rules. We as sume the Earley algorithm convention of a set of dotted productions, with the dot representing a position in the ordered right-hand-side elements. Agenda items represent states and their in dices relative to some input. As in chart parsing, the agenda will hold a list of items to be poten tially added to the parse table. There is flexibil ity in its management. Here we assume a FIFO queue. Advance (astate , istate The advance procedure is called by scan, com plete, and inverse-complete, to be defined shortly. As we have pointed out, active states are indexed at an element in the terminal yield of any poten tial next daughters to be matched (rather than the last one to have been matched), so they will be added to the parse table only if some tuple in the required relation can be shown to exist in the input. This question is satisfied by the query( expander, c' , Q) form. Here we assume that given an expander constraint and the daugh ters matched so far, a subroutine can dereference the arguments to the expander constraint, bind ing the already-bound one, and then execute a query that will return the members of the input that can bind the to-be-bound argument. indexed multidimensional set C, and a start ing element q that is an arbitrary member of C. et al., 1991) .", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 484, | |
| "end": 508, | |
| "text": "Advance (astate , istate", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 1360, | |
| "end": 1373, | |
| "text": "et al., 1991)", | |
| "ref_id": "FIGREF9" | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "We now turn to an Earley-style algorithm for the full class of Atomic Relational Grammars in", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Finally ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Although the Earley-style algorithm presented here is of interest in its own right, there are re maining issues in exploring incremental, predic tive parsing of visual language interfaces. To carry out the goal of providing an analogue of command completion in visual language inter faces requires at least two extensions beyond the work reported on here. First, more variations in scanning order are likely to be desired than what can be provided for here. Note that with the cur rent algorithm, the ordering variants relative to a single global scanning order are restricted to local permutations within rules. What may be desired is the multidimensional analogue of pre dictive parsing of free-word-order languages that can scramble not only within grammatical con stituents but also across constituents (subject to the connectness constraint). Further, algorithms more akin to island-based parsing (from a single island out) are likely to be preferable for interface parsing than the Earley-style algorithm presented here. Note that by following all permitted scan ning orders reachable from a given start position, the Earley-style algorithm expands multiple is lands in parallel, each of which may cover only part of the input globally processed so far.", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Ordering the constraints in a \u2022 grammar compiling operation as discussed here obviates the need for residuation in unification operations, the basis for the unification extensions discussed in Wittenburg (1993).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "This restriction to equality is significant only for expander attributes in percolation statements. The grammar for malism supports the use of additional features whose values may be tied to arbitrary computation using other features.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "If a scanning algorithm is desired that will allow for all orderings consistent with Restriction 1, then more variants can simply be produced here.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "In Wittenburg et al. {1991), active states were indexed by the already-bound argument. The change is necessary to make indexing of predictive states (which have no cover, and thus no bound argument) consistent with the indexing of other active states.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "A variant of this procedure must also accommodate input items from C directly in place of the inactive-state ar gument when called by the scan procedure. It is straightforward to form a (transient) inactive state from an input item.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "", | |
| "sec_num": null | |
| } | |
| ], | |
| "back_matter": [ | |
| { | |
| "text": "\u2022 <rule> or <category / feature vector>, ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "The following trace of a parsing run uses the grammar from Example 4 together with the input shown in Figure 3. This trace picks the rectan gle, indexed as 4, as the start element. Each step of the trace represents a state added to the table and includes the following information:", | |
| "sec_num": null | |
| } | |
| ], | |
| "bib_entries": { | |
| "BIBREF0": { | |
| "ref_id": "b0", | |
| "title": "Flow -> . P-block start end", | |
| "authors": [], | |
| "year": null, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "[flowchart-2: Flow -> . P-block start end), 0, ( 4), init.", | |
| "links": null | |
| }, | |
| "BIBREF1": { | |
| "ref_id": "b1", | |
| "title": "Flow -> . start P-block end", | |
| "authors": [], | |
| "year": null, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "[flowchart-I: Flow -> . start P-block end), 0, ( 4), init.", | |
| "links": null | |
| }, | |
| "BIBREF2": { | |
| "ref_id": "b2", | |
| "title": "P-block -> . decision P block junction", | |
| "authors": [], | |
| "year": null, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "[conditional-!: P-block -> . decision P block junction), 0, ( 4), init.", | |
| "links": null | |
| }, | |
| "BIBREF3": { | |
| "ref_id": "b3", | |
| "title": "P-block -> . junction P block decision", | |
| "authors": [], | |
| "year": null, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "[conditional-3: P-block -> . junction P block decision), 0, ( 4), init.", | |
| "links": null | |
| }, | |
| "BIBREF4": { | |
| "ref_id": "b4", | |
| "title": "P-block -> . P-block deci sion junction", | |
| "authors": [], | |
| "year": null, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "[conditional-2: P-block -> . P-block deci sion junction), 0, (4), init.", | |
| "links": null | |
| }, | |
| "BIBREF5": { | |
| "ref_id": "b5", | |
| "title": "4 :out 4), 4, ( 4)", | |
| "authors": [ | |
| { | |
| "first": "#s(p-Block", | |
| "middle": [], | |
| "last": "", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": null, | |
| "venue": "", | |
| "volume": "7", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "#S(P-block :in 4 :out 4), 4, ( 4), scan 7.", | |
| "links": null | |
| }, | |
| "BIBREF8": { | |
| "ref_id": "b8", | |
| "title": "1 :out 16", | |
| "authors": [ | |
| { | |
| "first": "#s(", | |
| "middle": [], | |
| "last": "Flow", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": null, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "#S(Flow :in 1 :out 16), 31, (16 1), scan 13.", | |
| "links": null | |
| }, | |
| "BIBREF9": { | |
| "ref_id": "b9", | |
| "title": "The Relational Lan guage System. \u2022 Bellcore Technical Memoran", | |
| "authors": [ | |
| { | |
| "first": "K", | |
| "middle": [], | |
| "last": "Wittenburg", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1992, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Wittenburg, K. (1992b) The Relational Lan guage System. \u2022 Bellcore Technical Memoran dum\u2022 TM-ARH-022353.", | |
| "links": null | |
| }, | |
| "BIBREF10": { | |
| "ref_id": "b10", | |
| "title": "F-PATR: Functional Constraints for Unification-based Gram mars", | |
| "authors": [ | |
| { | |
| "first": "K", | |
| "middle": [], | |
| "last": "Wittenburg", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1993, | |
| "venue": "Proceedings of the 31st Annual Meeting of the Association fo r Computational Linguistics", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "216--223", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Wittenburg, K. (1993) \"F-PATR: Functional Constraints for Unification-based Gram mars.\" In: Proceedings of the 31st Annual Meeting of the Association fo r Computational Linguistics, 216 -223.", | |
| "links": null | |
| } | |
| }, | |
| "ref_entries": { | |
| "FIGREF0": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "generally common in flowchart diagramming lan guages to represent control loops." | |
| }, | |
| "FIGREF1": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "Exam pie 1 shows a defining form for a sim pie rule that states that an object of type Subtree can be composed out of two objects of type prim and Row, as long as they stand in the stated be low and centered-in-x relations. The integers in the textual rule definition act as references to rule elements: the left-hand-side of a rule is conven tionally marked as b; the one or more right-hand side elements are numbered 1 .." | |
| }, | |
| "FIGREF2": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "Flowchart Grammar. (defrule (flovchart flovchart-grammar) (0 Flovchart (setf (in 0) 1 (out 0) 3) (1 oval) (2 P-block (connects-to 1 (in 2))) (3 oval (connects-to (out 2) 3)))) (defrule (conditional flovchart-grammar) (0 P-block (setf (in 0) 1 (out 0) 3) ) (1 diamond) (2 P-block (Y-connects-to 1 (in 2) )) (3 circle (connects-to (out 2) 3) (N-connects-to 1 3))) (defrule (basic-p-block flovchart-grammar) (0 P-block (setf (in 0) 1 (out 0 ) 1)) (1 rectangle) )A graphical depiction of the is shown inFigure 2. A visual indication that these relations do not hold of composite sets directly can be seen as the arcs (representing relations) cross the enclosing perimeters of nonterminal objects. All relations in this example are taken as constraints on indi vidual members of the input set. Consider, for example, the relational constraint (connects-to 1 (in 2)) appearing in rule flowchart . The first argu ment, 1, is a direct reference to a terminal object with lexical type oval . The second argument, (in 2), is an indirect reference to the value of the in attribute of an object of (nonterminal) type P block. This value will be bound to a terminal ob ject during parsing. We call the set of attributes expander attributes that appear in any of the ar guments to expander relations in a grammar. In this grammar, in and out are the expander at tributes. Graphical views of flowchart productions." | |
| }, | |
| "FIGREF4": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "An expression in L(FRG-gram)The rule set in Example 3 for the grammar we'll call FRG-gram generates Relational lan guage expressions such as that graphed inFigure 4. FRG-gram rule set." | |
| }, | |
| "FIGREF6": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "A triple < N, attr, P >, Na nonterminal category, 'attr' an expander at tribute, and P an ordered production of Atomic Relational Grammar g is in the starts-by-binding relation iff the left-hand side category of P = N and there exists a feature assignment statement of the form (attr 0) = 1 or (attr 0) = (attr' 1) in P." | |
| }, | |
| "FIGREF7": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "Extended Flowchart grammar. conditional flowchart-grammar) (0 P-block (setf (in 0) (in 1) (out 0) (out 3))) (1 decision) (2 P-block ) (3 junction) :expanders (Y-connects-to (out 1) (in 2)) (connects-to (out 2) (in 3) ) :predicates (N-connects-to (out 1) (in 3) ))" | |
| }, | |
| "FIGREF8": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "The first-attrs of an ordered pro duction pin Atomic Relational Grammar g is { attr x } I there exists an assignment state ment (attr y 0) = ( attr x 1) in p where attr x , y are expander attributes." | |
| }, | |
| "FIGREF9": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "i, ( d1 , ... d n )], and an inactive-state i-state = [cat, f, c] . 5 Output : A list of agenda items, possibly null, that are the result of advancing a-state with istate. Method: If i = length of rhs of p (new state will be inactive) , then let c' = union-covers( ( d1 ... d n ), c) and let f' = percolate(p, (d1 ... d n ), c, !). Return an agenda item [istate' = [cat', f', c'] , keys] where cat' = lhs of p and keys is the list of inactive state indices of i-state'. Case 2: (New state will be active.) Let a state' = [p, i + 1,c' = (d1 , ... d n ,c)]. Let e = expander-at-position(p, i + 1). Let q = query(expander, c' , Q). If q is non-null, return an agenda item [astate' , q] ." | |
| }, | |
| "FIGREF10": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": "Membership in .L(ARG) Input: An Atomic Relational Grammar = g, an \u2022" | |
| }, | |
| "FIGREF11": { | |
| "num": null, | |
| "type_str": "figure", | |
| "uris": null, | |
| "text": ", a few short remarks on related lit-. . WITTENBURGerature. In the theoretical graph grammar lit erature, there have been recent results suggest ing a natural class . for a useful and general class of graph grammars, namely, context-free hyper graph grammars of bounded degree (Englefreit, 1992). An interesting line of research would be to investigate the relationship between Atomic Re lational Grammars and Hypergraph grammars. The role of features and percolation in Atomic Relational Grammars seems to be quite similar to hyperedges and hyperedge replacement in Hyper graph Grammars. Elsewhere in the graph gram mar literature, an active chart parsing algorithm for flowgraphs has been proposed (Lutz, 1989; Wills 1990) that is related to the parsing algo rithm discussed here and \u2022 in Wittenburg et al. (1991). Again, the exact relationship between flowgraphs and Atomic Relational Languages is worthy of investigation. The most closely related parsing algorithms from the visual language literature are to be found in Tomita (1990) and Costagliola -Chang (1991), both of which extend Earley-style parsing into multidimensional domains. Although there is commonality at the level of parsing subroutines, indexing methods differ substantively. These dif ferences arise in part because of different assump tions regarding the nature of the input and the allowable relations. Both these other proposals assume that the input is held in a grid of somekind with elements of equal size. Relations are defined accordingly. There are no such assump tions here." | |
| }, | |
| "TABREF1": { | |
| "num": null, | |
| "html": null, | |
| "content": "<table><tr><td>A definition useful in subsequent sections on parsing follows:</td></tr><tr><td>Definition 1. We know, given Restriction 1, that for every ordered production, an ex pander constraint of the form ( rel x y) must exist for every ordered daughter at position j > 1 where either x or y will be grounded by matching a daughter at position j and either x or y (whichever doesn't satisfy this previous condition) is already grounded by a daughter at a position i < j. These ar guments are defined as the to-be-bound ar gument and the already-bound argument, respectively, at position j.</td></tr><tr><td>A fundamental issue in Relational Grammar representation is whether to allow nonterminals to appear as direct arguments to relational con straints. The natural interpretation of a nonter minal in such a constraint is that it is a reference to the set of input objects in its derivational yield. Let us presume a grammar having the rule in Ex ample 1 has other rules expanding the nontermi nal category Row in such a way that a bottom up parser can build up a horizontally aligned set of primitive objects. Consider the effect of exe cuting the query (below :? i), mentioned earlier, when parsing.</td></tr></table>", | |
| "type_str": "table", | |
| "text": "If this query is executed against the original input only, it will never find a Row object since the existence of such an object is an artifact of parsing. A solution to this problem requires dynamic updating of what we call an ob ject store, which starts out as a collection of input objects. Composite objects are introduced as the parser finds them through rule matches. A gram mar thus must define derived nonterminal objects in terms of terminal objects. For example, if in put data is characterized as rectangular regions (which is reasonable for many graphical applica tions), then composites introduced through rule matches might be defined as the summation of the rectangular regions of the rule's daughters. Including relational constraints directly on composites is reasonable when using bottom-up parsing, but it complicates the definition of Rela tional Grammars as generative systems since the composition-of relation must in principle be re versible. Further, significant problems are intro duced for Earley-style parsing, or any other form of predictive parsing, as discussed in" | |
| }, | |
| "TABREF2": { | |
| "num": null, | |
| "html": null, | |
| "content": "<table><tr><td>can Restriction 3. Each relation used in an ex-pander constraint in the grammar must in dependently be a partial order.</td></tr><tr><td>Restriction 4. For each expander relation used in the grammar, a pair of minimal/maximal expander attributes must be declared and every production must percolate values to these attributes in a manner that retains the partial orderings.</td></tr></table>", | |
| "type_str": "table", | |
| "text": "be (partially) ordered. The motivation for such a requirement is that if we can partially or der the input, then starting positions can be de fined as the minimal elements and the parser can be given a partial order for scanning the input. This is a summary of the restrictions on Atomic Relational Grammars that define the Fringe Relational Grammar subclass." | |
| }, | |
| "TABREF3": { | |
| "num": null, | |
| "html": null, | |
| "content": "<table/>", | |
| "type_str": "table", | |
| "text": "" | |
| }, | |
| "TABREF5": { | |
| "num": null, | |
| "html": null, | |
| "content": "<table><tr><td colspan=\"2\">Nonterm Expander Attribute</td><td>Production Variant</td></tr><tr><td>Flow</td><td>in out start</td><td>flowchart-I flowchart-2 flowchart-I flowchart-2 flowchart</td></tr></table>", | |
| "type_str": "table", | |
| "text": "" | |
| }, | |
| "TABREF8": { | |
| "num": null, | |
| "html": null, | |
| "content": "<table><tr><td>Auxiliary data structures:</td></tr><tr><td>Agenda: a FIFO list of states to process, initially null.</td></tr><tr><td>lnit-states: the set of starting predictive states, initialized as follows: For every p in starts-by-binding(S, start), add a state [p, 1, null] to init-states. For ev ery state s = [p', 1, null] in init-states, if the rhs symbol X at rhs position 1 of p' . is a nonterminal, then let init states = union(init-states, starts-by binding( X, start)).</td></tr><tr><td>Method: We initialize as follows:</td></tr><tr><td>\u2022 For every . s in init-states, add an agenda item [s, {q}] to the Agenda.</td></tr><tr><td>\u2022 Until Agenda is empty, do:</td></tr><tr><td>-Remove one item = [state, keys] from Agenda. -For k in keys, ifan equivalent state is not already at Sk , add state at Sk . Then do: Scanner: d n )] at k is active and the rhs symbol x at position i of p is terminal, if the terminal sym bol of input item = y at k matches x and k does not in tersect cover( state), then add any item in advance(state, . y, k) to Agenda.</td></tr></table>", | |
| "type_str": "table", | |
| "text": "Output: A parse table of state sets S i . Parse table: a hash table of state sets S j , where j is an . index to individuals in C. If state = [p, i, ( d1 ..." | |
| } | |
| } | |
| } | |
| } |