|
|
| Line 1: |
Line 1: |
| Range Concatenation Grammar (RCG) is a grammar formalism developed by Pierre Boullier <ref name="boullier1998">Boullier, Pierre. 1998. Proposal for a Natural Language Processing Syntactic Backbone. In ''Research Report No 3342'', INRIA. Rocquencourt, France.</ref> in 1998 as an attempt to characterize a number of phenomena of natural language, such as Chinese numbers and German word order scrambling, which are outside the bounds of the [[Mildly context-sensitive language]]s.<ref name="boullier1999">Pierre Boullier. 1999. Chinese Numbers, MIX, Scrambling, and Range Concatenation Grammars. In Proceedings of EACL, pages 53–60, Bergen, Norway.</ref>
| | I'm Geneva and I live in Zizers. <br>I'm interested in Computing and Information Science, Book collecting and Spanish art. I like to travel and reading fantasy.<br><br>Also visit my blog post ... [https://presscbu.cbnu.ac.kr:54764/?document_srl=7025821 don't want to write my paper] |
| | |
| From a theoretical point of view, any language that can be parsed in polynomial time belongs to the subset of RCG called Positive range concatenation grammars, and reciprocally.
| |
| | |
| Though intended as a variant on Groenink's [[Literal movement grammar]]s, RCGs treat the grammatical process more as a proof than as a production. Whereas LMGs produce a terminal string from a start predicate, RCGs aim to reduce a start predicate (which predicates of a terminal string) to the empty string, which constitutes a proof of the terminal strings membership in the language.
| |
| | |
| ==Description==
| |
| | |
| === Formal definition ===
| |
| A '''Positive Range Concatenation Grammar''' (PRCG) is a tuple <math> G = (N,~T,~V,~S,~P)</math>, where:
| |
| * <math>N</math>, <math>T</math> and <math>V</math> are disjoint finite sets of (respectively) ''predicate names'', ''terminal symbols'' and ''variable names''. Each predicate name has an associated arity given by the function <math>dim: N \rightarrow \mathbb{N}\setminus\{0\}</math>.
| |
| * <math>S \in N</math> is the start predicate name and verify <math>dim(S)=1</math>.
| |
| * <math>P</math> is a finite set of ''clauses'' of the form <math>\psi_0 \rightarrow \psi_1 \ldots \psi_m</math>, where the <math>\psi_i</math> are ''predicates'' of the form <math>A_i(\alpha_1, \ldots, \alpha_{dim(A_i)})</math> with <math>A_i \in N</math> and <math>\alpha_i \in (T \cup V)^\star</math>.
| |
| | |
| A '''Negative Range Concatenation Grammar''' (NRCG) is defined like a PRCG, but with the addition that some predicates occurring in the right-hand side of a clause can have the form <math>\overline{A_i(\alpha_1, \ldots, \alpha_{dim(A_i)})}</math>. Such predicates are called ''negative predicates''.
| |
| | |
| A '''Range Concatenation Grammar''' is a positive or a negative one. Although PRCGs are technically NRCGs, the terms are used to highlight the absence (PRCG) or presence (NRCG) of negative predicates.
| |
| | |
| A '''range''' in a word <math>w \in T^\star</math> is a couple <math>\langle l, r \rangle_w</math>, with <math>0 \leq l \leq r \leq n</math>, where <math>n</math> is the length of <math>w</math>. Two ranges <math>\langle l_1, r_1 \rangle_w</math> and <math>\langle l_2, r_2 \rangle_w</math> can be concatenated iff <math>r_1 = l_2</math>, and we then have: <math>\langle l_1, r_1 \rangle_w \cdot \langle l_2, r_2 \rangle_w = \langle l_1, r_2 \rangle_w</math>.
| |
| | |
| For a word <math>w = w_1w_2\ldots w_n</math>, with <math>w_i \in T</math>, the '''dotted notation''' for ranges is: <math>\langle l, r \rangle_w = w_1\ldots w_{l-1} \bullet w_l\ldots w_{r-1} \bullet w_r\ldots w_n</math>.
| |
| | |
| === Recognition of strings ===
| |
| Like LMGs, RCG clauses have the general schema <math>A(x_1, ..., x_n) \to \alpha</math>, where in an RCG, <math>\alpha</math> is either the empty string or a string of predicates. The arguments <math>x_i</math> consist of strings of terminal symbols and/or variable symbols, which pattern match against actual argument values like in LMG. Adjacent variables constitute a family of matches against partitions, so that the argument <math>xy</math>, with two variables, matches the literal string <math>ab</math> in three different ways: <math>x = \epsilon,\ y = ab;\ x = a,\ y = b;\ x = ab,\ y = \epsilon</math>.
| |
| | |
| Predicate terms come in two forms, positive (which produce the empty string on success), and negative (which produce the empty string on failure/if the positive term does ''not'' produce the empty string). Negative terms are denoted the same as positive terms, with an overbar, as in <math>\overline{A(x_1, ..., x_n)}</math>.
| |
| | |
| The rewrite semantics for RCGs is rather simple, identical to the corresponding semantics of LMGs. Given a predicate string <math>A(\alpha_1, ..., \alpha_n)</math>, where the symbols <math>\alpha_i</math> are terminal strings, if there is a rule <math>A(x_1, ..., x_n) \to \beta</math> in the grammar that the predicate string matches, the predicate string is replaced by <math>\beta</math>, substituting for the matched variables in each <math>x_i</math>.
| |
| | |
| For example, given the rule <math>A(x, ayb) \to B(axb, y)</math>, where <math>x</math> and <math>y</math> are variable symbols and <math>a</math> and <math>b</math> are terminal symbols, the predicate string <math>A(a, abb)</math> can be rewritten as <math>B(aab, b)</math>, because <math>A(a, abb)</math> matches <math>A(x, ayb)</math> when <math>x = a,\ y = b</math>. Similarly, if there were a rule <math>A(x, ayb) \to A(x, x)\ A(y, y)</math>, <math>A(a, abb)</math> could be rewritten as <math>A(a, a)\ A(b, b)</math>.
| |
| | |
| A proof/recognition of a string <math>\alpha</math> is done by showing that <math>S(\alpha)</math> produces the empty string. For the individual rewrite steps, when multiple alternative variable matches are possible, any rewrite which could lead the whole proof to succeed is considered. Thus, if there is at least one way to produce the empty string from the initial string <math>S(\alpha)</math>, the proof is considered a success, regardless of how many other ways to fail exist.
| |
| | |
| ==Example== | |
| | |
| RCGs are capable of recognizing the non-linear index language <math>\{ www : w \in \{a,b\}^{*} \}</math> as follows:
| |
| | |
| Letting x, y, and z be variable symbols:
| |
| | |
| | |
| <math>S(xyz) \to A(x, y, z)</math>
| |
| | |
| <math>A(ax, ay, az) \to A(x, y, z)</math>
| |
| | |
| <math>A(bx, by, bz) \to A(x, y, z)</math>
| |
| | |
| <math>A(\epsilon, \epsilon, \epsilon) \to \epsilon</math>
| |
| | |
| | |
| The proof for ''abbabbabb'' is then
| |
| | |
| <math>S(abbabbabb) \Rightarrow A(abb, abb, abb) \Rightarrow A(bb, bb, bb) \Rightarrow A(b, b, b) \Rightarrow A(\epsilon, \epsilon, \epsilon) \Rightarrow \epsilon</math>
| |
| | |
| Or, using the more correct dotted notation for ranges:
| |
| | |
| <math>S(\bullet{}abbabbabb\bullet{}) \Rightarrow A(\bullet{}abb\bullet{}abbabb, abb\bullet{}abb\bullet{}abb, abbabb\bullet{}abb\bullet{}) \Rightarrow A(a\bullet{}bb\bullet{}abbabb, abba\bullet{}bb\bullet{}abb, abbabba\bullet{}bb\bullet{})</math> <math>\Rightarrow A(ab\bullet{}b\bullet{}abbabb, abbab\bullet{}b\bullet{}abb, abbabbab\bullet{}b\bullet{}) \Rightarrow A(\epsilon, \epsilon, \epsilon) \Rightarrow \epsilon</math>
| |
| | |
| ==References==
| |
| | |
| <references/>
| |
| | |
| {{Formal languages and grammars}}
| |
| | |
| [[Category:Formal languages]]
| |
| [[Category:Grammar frameworks]]
| |
I'm Geneva and I live in Zizers.
I'm interested in Computing and Information Science, Book collecting and Spanish art. I like to travel and reading fantasy.
Also visit my blog post ... don't want to write my paper