Controlled grammar

Language controlled grammars are grammars in which the production sequences constitute a well-defined language of arbitrary nature, usually though not necessarily regular, over a set of (again usually though not necessarily) context-free production rules. They also often have a sixth set in the grammar tuple, making it ${\displaystyle G=(N,T,S,P,R,F)}$, where F is a set of productions that are allowed to apply vacuously. This version of language controlled grammars, ones with what is called "appearance checking", is the one henceforth.

We let a regularly controlled context-free grammar with appearance checking be a 6-tuple ${\displaystyle G=(N,T,S,P,R,F)}$ where N, T, S, and P are defined as in CFGs, R is a subset of P* constituting a regular language over P, and F is some subset of P. We then define the immediately derives relation ${\displaystyle \Rightarrow _{p_{i}}}$ as follows:

Given some strings x and y, both in ${\displaystyle (N\cup T)^{*}}$, and some rule ${\displaystyle p=A\to w\in P}$,

${\displaystyle x\Rightarrow _{p}^{ac}y}$

holds if either

${\displaystyle x=x_{1}Ax_{2}}$ and ${\displaystyle y=y_{1}wy_{2}}$, or

${\displaystyle x=y}$ and ${\displaystyle p\in F}$

Intuitively, this simply spells out that a rule can apply to a string if the rule's left-hand-side appears in that string, or if the rule is in the set of "vacuously applicable" rules which can "apply" to a string without changing anything. This requirement that the non-vacuously applicable rules must apply is the appearance checking aspect of such a grammar. The language for this kind of grammar is then simply set of terminal strings ${\displaystyle L(G)=\{w\in T^{*}:S\Rightarrow _{p_{1}}^{ac}w_{1}\Rightarrow _{p_{2}}^{ac}w_{2}\Rightarrow _{p_{3}}^{ac}...\Rightarrow _{p_{n}}^{ac}w,\ for\ some\ p_{1}p_{2}...p_{n}\in R\}}$.

Consider a simple (though not the simplest) context-free grammar that generates the language ${\displaystyle \{a^{n}:n\geq 1\}}$:

Let ${\displaystyle G=(\{S,A,X\},\{a\},S,\{f,g,h,k,l\})}$, where

${\displaystyle f:S\to AA}$

${\displaystyle g:S\to X}$

${\displaystyle h:A\to S}$

${\displaystyle k:A\to X}$

${\displaystyle l:S\to a}$

In language controlled form, this grammar is simply ${\displaystyle G^{\prime }=(\{S,A,X\},\{a\},S,\{f,g,h,k,l\},(f|g|h|k|l)^{*},\{f,g,h,k,l\})}$ (where ${\displaystyle (f|g|h|k|l)^{*}}$ is a regular expression denoting the set of all sequences of production rules). A simple modification to this grammar, changing is control sequence set R into the set ${\displaystyle (f^{*}gh^{*}k)^{*}l^{*}}$, and changing its vacuous rule set F to ${\displaystyle \{g,k\}}$, yields a grammar which generates the non-CF language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$. To see how, consider the general case of some string with n instances of S in it, i.e. ${\displaystyle S^{n}}$ (the special case ${\displaystyle S^{1}}$ trivially derives the string a which is ${\displaystyle a^{2^{0}}}$, an uninteresting fact).

If we chose some arbitrary production sequence ${\displaystyle f^{u}gh^{v}k...}$, we can consider three possibilities: ${\displaystyle n=u}$, ${\displaystyle n<u}$, and ${\displaystyle n>u}$ When ${\displaystyle n=u}$ we rewrite all n instances of S as AA, by applying rule f to the string u times, and proceed to apply g, which applies vacuously (by virtue of being in F) . When ${\displaystyle n<u}$, we rewrite all n instances of S as AA, and then try to perform the n+1 rewrite using rule f, but this fails because there are no more Ss to rewrite, and f is not in F and so cannot apply vacuously, thus when ${\displaystyle n<u}$, the derivation fails. Lastly, then ${\displaystyle n>u}$, we rewrite u instances of S, leaving at least one instance of S to be rewritten by the subsequent application of g, rewriting S as X. Given that no rule of this grammar ever rewrites X, such a derivation is destined to never produce a terminal string. Thus only derivations with ${\displaystyle n=u}$ will ever successfully rewrite the string ${\displaystyle S^{n}}$. Similar reasoning holds of the number of As and v. In general, then, we can say that the only valid derivations have the structure ${\displaystyle S^{n}\Rightarrow _{f}...\Rightarrow _{f}A^{2n}\Rightarrow {g}A^{2n}\Rightarrow {h}...\Rightarrow {h}S^{2n}\Rightarrow {k}S^{2n}}$ will produce terminal strings of the grammar. The X rules, combined with the structure of the control, essentially force all Ss to be rewritten as AAs prior to any As being rewritten as Ss, which again is forced to happen prior to all still later iterations over the S-to-AA cycle. Finally, the Ss are rewritten as as. In this way, the number of Ss doubles each for each instantiation of ${\displaystyle f^{8}gh^{*}k}$ that appears in a terminal-deriving sequence.

Choosing two random non-terminal deriving sequences, and one terminal-deriving one, we can see this in work:

Let ${\displaystyle s_{1}=ffghkll}$, then we get the failed derivation:

${\displaystyle S\Rightarrow _{f}^{ac}AA\Rightarrow _{f}^{ac}{\text{failure: f cannot apply, no S to rewrite}}}$

Let ${\displaystyle s_{2}=fghhhkll}$, then we get the failed derivation:

${\displaystyle S\Rightarrow _{f}^{ac}AA\Rightarrow _{g}^{ac}AA\Rightarrow _{h}^{ac}SA\Rightarrow _{h}^{ac}SS\Rightarrow _{h}^{ac}{\text{failure: h cannot apply, no A to rewrite}}}$

Let ${\displaystyle s_{3}=fghhkll}$, then we get the successful derivation:

${\displaystyle S\Rightarrow _{f}^{ac}AA\Rightarrow _{g}^{ac}AA\Rightarrow _{h}^{ac}SA\Rightarrow _{h}^{ac}SS\Rightarrow _{k}^{ac}SS\Rightarrow _{l}^{ac}aS\Rightarrow _{l}^{ac}aa}$

Similar derivations with a second cycle of ${\displaystyle f^{*}gh^{*}k}$ produce only SSSS. Showing only the (continued) successful derivation:

${\displaystyle ...\Rightarrow SS\Rightarrow _{f}^{ac}AAS\Rightarrow _{f}^{ac}AAAA\Rightarrow _{g}^{ac}AAAA}$

${\displaystyle \Rightarrow _{h}^{ac}SAAA\Rightarrow _{h}^{ac}SSAA\Rightarrow _{h}^{ac}SSSA\Rightarrow _{h}^{ac}SSSS\Rightarrow _{k}^{ac}SSSS}$

${\displaystyle \Rightarrow _{l}^{ac}aSSS\Rightarrow _{l}^{ac}aaSS\Rightarrow _{l}^{ac}aaaS\Rightarrow _{l}^{ac}aaaa}$

Matrix grammars (expanded on in their own article) are a special case of regular controlled context-free grammars, in which the production sequence language is of the form ${\displaystyle (m_{1}|m_{2}|...|m_{n})^{*}}$, where each "matrix" ${\displaystyle m_{i}}$ is a single sequence. For convenience, such a grammar is not represented with a grammar over P, but rather with just a set of the matrices in place of both the language and the production rules. Thus, a matrix grammar is the 5-tuple ${\displaystyle G=(N,T,M,S,F)}$, where N, T, S, and F are defined essentially as previously done (with F a subset of M this time), and M is a set of matrices ${\displaystyle m_{i}=p_{i,1}p_{i,2}...p_{i,n_{i}}}$ where each ${\displaystyle p_{i,j}}$ is a context-free production rule.

The derives relation in a matrix grammar is thus defined simply as:

Given some strings x and y, both in ${\displaystyle (N\cup T)^{*}}$, and some matrix ${\displaystyle m=p_{1}p_{2}...p_{n}\in M}$,

${\displaystyle x\Rightarrow _{m}^{ac}y}$

holds if either

${\displaystyle x=x_{1}Ax_{2}}$, ${\displaystyle y=y_{1}wy_{2}}$, and ${\displaystyle A\Rightarrow _{p_{1}}^{ac}w_{1}\Rightarrow _{p_{2}}^{ac}w_{2}\Rightarrow _{p_{3}}^{ac}...\Rightarrow _{p_{n}}^{ac}w}$, or

${\displaystyle x=y}$ and ${\displaystyle m\in F}$

Informally, a matrix grammar is simply a grammar in which during each rewriting cycle, a particular sequence of rewrite operations must be performed, rather than just a single rewrite operation, i.e. one rule "triggers" a cascade of other rules. Similar phenomena can be performed in the standard context-sensitive idiom, as done in rule-based phonology and earlier Transformational grammar, by what are known as "feeding" rules, which alter a derivation in such a way as to provide the environment for a non-optional rule that immediately follows it.

Vector grammars are closely related to matrix grammars, and in fact can be seen as a special class of matrix grammars, in which if ${\displaystyle m\in M}$, then so are all of its permutations ${\displaystyle p(m)}$. For convenience, however, we will define vector grammars as follows: a vector grammar is a 5-tuple ${\displaystyle G=(N,T,M,S,F)}$, where N, T, and F are defined previously (F being a subset of M again), and where M is a set of vectors ${\displaystyle m_{i}=\{p_{1},p_{2},...,p_{n}\}}$, each vector being a set of context free rules.

The derives relation in a vector grammar is then:

Given some strings x and y, both in ${\displaystyle (N\cup T)^{*}}$, and some matrix ${\displaystyle m=\{p_{1},p_{2},...,p_{n}\}\in M}$,

${\displaystyle x\Rightarrow _{m}^{ac}y}$

holds if either

${\displaystyle x=x_{1}Ax_{2}}$, ${\displaystyle y=y_{1}wy_{2}}$, and ${\displaystyle A\Rightarrow _{p_{i_{1}}}^{ac}w_{1}\Rightarrow _{p_{i_{2}}}^{ac}w_{2}\Rightarrow _{p_{i_{3}}}^{ac}...\Rightarrow _{p_{i_{n}}}^{ac}w}$, where ${\displaystyle m=\{p_{i_{1}},p_{i_{2}},...,p_{i_{n}}\}}$, or

${\displaystyle x=y}$ and ${\displaystyle m\in F}$

Notice that the number of production rules used in the derivation sequence, n, is the same as the number of production rules in the vector. Informally, then, a vector grammar is one in which a set of productions is applied, each production applied exactly once, in arbitrary order, to derive one string from another. Thus vector grammars are almost identical to matrix grammars, minus the restriction on the order in which the productions must occur during each cycle of rule application.

Programmed grammars are relatively simple extensions to context-free grammars with rule-by-rule control of the derivation. A programmed grammar is a 4-tuple ${\displaystyle G=(N,T,S,P)}$, where N, T, and S are as in a context-free grammar, and P is a set of tuples ${\displaystyle (p,\sigma ,\phi )}$, where p is a context-free production rule, ${\displaystyle \sigma }$ is a subset of P (called the success field), and ${\displaystyle \phi }$ is a subset of P (called the failure field). If the failure field of every rule in P is empty, the grammar lacks appearance checking, and if at least one failure field is not empty, the grammar has appearance checking. The derivation relation on a programmed grammar is defined as follows:

Given two strings ${\displaystyle x,y\in (N\cup T)^{*}}$, and some rule ${\displaystyle p=(A\to w,\sigma ,\phi )\in P}$,

${\displaystyle x\Rightarrow _{p}y}$ and ${\displaystyle x=x'Ax'',y=x'wx''}$, or

${\displaystyle x=y}$ and A does not appear in x.

The language of a programmed grammar G is defined by constraining the derivation rule-wise, as ${\displaystyle L(G)=\{w\in (N\cup T)^{*}:S\Rightarrow _{p_{1}}w_{1}\Rightarrow _{p_{2}}...\Rightarrow _{p_{n}}w\}}$, where for each ${\displaystyle p_{i}=(A_{i}\to v_{i},\sigma _{i},\phi _{i})}$, either ${\displaystyle w_{i-1}=x_{i-1}Ax'_{i-1},w_{i}=x_{i-1}v_{i}x'_{i-1},\ and\ p_{i+1}\in \sigma _{i}}$ or ${\displaystyle w_{i-1}=w_{i},p_{i+1}\in \phi _{i}}$.

Intuitively, when applying a rule p in a programmed grammar, the rule can either succeed at rewriting a symbol in the string, in which case the subsequent rule must be in ps success field, or the rule can fail to rewrite a symbol (thus applying vacuously), in which case the subsequent rule must be in ps failure field. The choice of which rule to apply to the start string is arbitrary, unlike in a language controlled grammar, but once a choice is made the rules that can be applied after it constrain the sequence of rules from that point on.

As with so many controlled grammars, programmed grammars can generate the language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$:

Let ${\displaystyle G=(\{S,A\},\{a\},S,\{r_{1},r_{2},r_{3}\})}$, where

${\displaystyle r_{1}=(S\to AA,\{r_{1}\},\{r_{2}\})}$

${\displaystyle r_{2}=(A\to S,\{r_{2}\},\{r_{1},r_{3}\})}$

${\displaystyle r_{3}=(S\to a,\{r_{3}\},\emptyset )}$

The derivation for the string aaaa is as follows:

${\displaystyle S\Rightarrow _{r_{1}}AA\Rightarrow _{r_{1}}AA\Rightarrow _{r_{2}}SA\Rightarrow _{r_{2}}SS\Rightarrow _{r_{2}}SS}$

${\displaystyle \Rightarrow _{r_{1}}AAS\Rightarrow _{r_{1}}AAAA\Rightarrow _{r_{1}}AAAA}$

${\displaystyle \Rightarrow _{r_{2}}SAAA\Rightarrow _{r_{2}}SSAA\Rightarrow _{r_{2}}SSSA\Rightarrow _{r_{2}}SSSS\Rightarrow _{r_{2}}SSSS}$

${\displaystyle \Rightarrow _{r_{3}}aSSS\Rightarrow _{r_{3}}aaSS\Rightarrow _{r_{3}}aaaS\Rightarrow _{r_{3}}aaaa\Rightarrow _{r_{3}}aaaa}$

As can be seen from the derivation and the rules, each time ${\displaystyle r_{1}}$ and ${\displaystyle r_{2}}$ succeed, they feed back to themselves, which forces each rule to continue to rewrite the string over and over until it can do so no more. Upon failing, the derivation can switch to a different rule. In the case of ${\displaystyle r_{1}}$, that means rewriting all Ss as AAs, then switching to ${\displaystyle r_{2}}$. In the case of ${\displaystyle r_{2}}$, it means rewriting all As as Ss, then switching either to ${\displaystyle r_{1}}$, which will lead to doubling the number of Ss produced, or to ${\displaystyle r_{3}}$ which converts the Ss to as then halts the derivation. Each cycle through ${\displaystyle r_{1}}$ then ${\displaystyle r_{2}}$ therefore either doubles the initial number of Ss, or converts the Ss to as. The trivial case of generating a, in case it is difficult to see, simply involves vacuously applying ${\displaystyle r_{1}}$, thus jumping straight to ${\displaystyle r_{2}}$ which also vacuously applies, then jumping to ${\displaystyle r_{3}}$ which produces a.

Conditional grammars are the simplest version of grammars controlled by context conditions. The structure of a conditional grammar is very similar to that of a normal rewrite grammar: ${\displaystyle G=(N,T,S,P)}$, where N, T, and S are as defined in a context-free grammar, and P is a set of pairs of the form ${\displaystyle (p,R)}$ where p is a production rule (usually context-free), and R is a language (usually regular) over ${\displaystyle N\cup T}$. When R is regular, R can just be expressed as a regular expression.

With this definition of a conditional grammar, we can define the derives relation as follows:

Given two strings ${\displaystyle x,y\in (N\cup T)^{*}}$, and some production rule ${\displaystyle p=(A\to w,R)\in P}$,

${\displaystyle x\Rightarrow _{p}y}$ if and only if ${\displaystyle x=x'Ax''}$, ${\displaystyle y=x'wx''}$, and ${\displaystyle x\in R}$

Informally then, the production rule for some pair in P can apply only to strings that are in its context language. Thus, for example, if we had some pair ${\displaystyle (S\to x,a^{*}Sb^{*})}$, we can only apply this to strings consisting of any number of as followed by exactly only S followed by any number of bs, i.e. to sentences in ${\displaystyle \{a^{m}Ab^{n}:m,n\geq 0\}}$, such as the strings S, aSb, aaaS, aSbbbbbb, etc. It cannot apply to strings like xSy, aaaSxbbb, etc.

Conditional grammars can generate the context-sensitive language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$.

Let ${\displaystyle G=(\{S,S'\},\{a\},\{f,g,h\},S)}$, where

${\displaystyle f=(S\to AA,A^{*}S^{+})}$

${\displaystyle g=(A\to B,B^{*}A^{+})}$

${\displaystyle h=(B\to S,S^{*}B^{+})}$

${\displaystyle k=(S\to a,a^{*}S^{+})}$

We can then generate the sentence aaaa with the following derivation:

${\displaystyle S\Rightarrow _{f}AA\Rightarrow _{g}BA\Rightarrow _{g}BB}$

${\displaystyle \Rightarrow _{h}SB\Rightarrow _{h}SS\Rightarrow _{f}AAS\Rightarrow _{f}AAAA}$

${\displaystyle \Rightarrow _{g}BAAA\Rightarrow _{g}BBAA\Rightarrow _{g}BBBA\Rightarrow _{g}BBBB}$

${\displaystyle \Rightarrow _{h}SBBB\Rightarrow _{h}SSBB\Rightarrow _{h}SSSB\Rightarrow _{h}SSSS}$

${\displaystyle \Rightarrow _{k}aSSS\Rightarrow _{k}aaSS\Rightarrow _{k}aaaS\Rightarrow _{k}aaaa}$

A semi-conditional grammar is very similar to a conditional grammar, and technically the class of semi-conditional grammars are a subset of the conditional grammars. Rather than specifying what the whole of the string must look like for a rule to apply, semi-conditional grammars specify that a string must have as substrings all of some set of strings, and none of another set, in order for a rule to apply. Formally, then, a semi-conditional grammar is a tuple ${\displaystyle G=(N,T,S,P)}$, where, N, T, and S are defined as in a CFG, and P is a set of rules like ${\displaystyle (p,R,Q)}$ where p is a (usually context-free) production rule, and R and Q are finite sets of strings. The derives relation can then be defined as follows.

For two strings ${\displaystyle xAx',xwx'\in (N\cup T)^{*}}$, and some rule ${\displaystyle p=(A\to w,R,Q)\in P}$,

${\displaystyle xAx'\Rightarrow _{p}xwx'}$ if and only if every string in R is a substring of ${\displaystyle xAx'}$, and no string in Q is a substring of ${\displaystyle xAx'}$

The language of a semi-conditional grammar is then trivially the set of terminal strings ${\displaystyle L(G)=\{w\in T^{*}:S\Rightarrow ^{*}w\}}$.

An example of a semi-conditional grammar is given below also as an example of random context grammars.

A random context grammar is a semi-conditional grammar in which the R and Q sets are all subsets of N. Because subsets of N are finite sets over ${\displaystyle (N\cup T)^{*}}$, it is clear that random context grammars are indeed kinds of semi-conditional grammars.

Like conditional grammars, random context grammars (and thus semi-conditional grammars) can generate the language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$. One grammar which can do this is:

Let ${\displaystyle G=(\{S,X,Y,A\},\{a\},S,\{r_{1},r_{2},r_{3},r_{4},r_{5}\})}$, where

${\displaystyle r_{1}=(S\to XX,\emptyset ,\{Y,A\})}$

${\displaystyle r_{2}=(X\to Y,\emptyset ,\{S\})}$

${\displaystyle r_{3}=(Y\to S,\emptyset ,\{X\})}$

${\displaystyle r_{4}=(S\to A,\emptyset ,\{X\})}$

${\displaystyle r_{5}=(A\to a,\emptyset ,\{S\})}$

Consider now the production for aaaa:

${\displaystyle S\Rightarrow _{r_{1}}XX\Rightarrow _{r_{2}}YX\Rightarrow _{r_{2}}YY\Rightarrow _{r_{3}}SY\Rightarrow _{r_{3}}SS}$

${\displaystyle \Rightarrow _{r_{1}}XXS\Rightarrow _{r_{1}}XXXX\Rightarrow _{r_{2}}YXXX\Rightarrow _{r_{2}}YYXX\Rightarrow _{r_{2}}YYYX\Rightarrow _{r_{2}}YYYY}$

${\displaystyle \Rightarrow _{r_{3}}SYYY\Rightarrow _{r_{3}}SSYY\Rightarrow _{r_{3}}SSSY\Rightarrow _{r_{3}}SSSS}$

${\displaystyle \Rightarrow _{r_{4}}ASSS\Rightarrow _{r_{4}}AASS\Rightarrow _{r_{4}}AAAS\Rightarrow _{r_{4}}AAAA}$

${\displaystyle \Rightarrow _{r_{5}}aAAA\Rightarrow _{r_{5}}aaAA\Rightarrow _{r_{5}}aaaA\Rightarrow _{r_{5}}aaaa}$

The behavior of the R sets here is trivial: any string can be rewritten according to them, because they do not require any substrings to be present. The behavior of the Q sets, however, are more interesting. In ${\displaystyle r_{1}}$, we are forced by the Q set to rewrite an S, thus beginning an S-doubling process, only when no Ys or As are present in the string, which means only when a prior S-doubling process has been fully initiated, eliminating the possibility of only doubling some of the Ss. In ${\displaystyle r_{2}}$, which moves the S-doubling process into its second stage, we cannot begin this process until the first stage is complete and there are no more Ss to try to double, because the Q set prevents the rule from applying if there is an S symbol still in the string. In ${\displaystyle r_{3}}$, we complete the doubling stage by introducing the Ss back only when there are no more Xs to rewrite, thus when the second stage is complete. We can cycle through these stages as many times as we want, rewriting all Ss to XXs before then rewriting each X to a Y, and then each Y to an S, finally ending by replacing each S with an A and then an a. Because the rule for replacing S with A prohibits application to a string with an X in it, we cannot apply this in the middle of the first stage of the S-doubling process, thus again preventing us from only doubling some Ss.

Ordered grammars are perhaps one of the simpler extensions of grammars into the controlled grammar domain. An ordered grammar is simply a tuple ${\displaystyle G=(N,T,S,P)}$ where N, T, and S are identical to those in a CFG, and P is a set of context-free rewrite rules with a partial ordering ${\displaystyle <}$. The partial ordering is then used to determine which rule to apply to a string, when multiple rules are applicable. The derives relation is then:

Given some strings ${\displaystyle xAx',xwx'\in (N\cup T)^{*}}$ and some rule ${\displaystyle p=A\to w\in P}$,

${\displaystyle xAx'\Rightarrow _{p}xwx'}$ if and only if there is no rule ${\displaystyle p'=A\to w'\in P}$ such that ${\displaystyle p<p'}$.

Like many other contextually controlled grammars, ordered grammars can enforce the application of rules in a particular order. Since this is the essential property of previous grammars that could generate the language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$, it should be no surprise that a grammar that explicitly uses rule ordering, rather than encoding it via string contexts, should similarly be able to capture that language. And as it turns out, just such an ordered grammar exists:

Let ${\displaystyle G=(\{S,X,Y,Z,A\},\{a\},S,P)}$, where P is the partially ordered set described by the Hasse diagram

The derivation for the string aaaa is simply:

${\displaystyle S\Rightarrow _{S\to XX}\ XX\ \Rightarrow _{X\to Y}\ YX\ \Rightarrow _{X\to Y}\ YY\ \Rightarrow _{Y\to S}\ SY\ \Rightarrow _{Y\to S}\ YY}$

${\displaystyle \Rightarrow _{S\to XX}\ XXS\ \Rightarrow _{S\to XX}\ XXXX}$

${\displaystyle \Rightarrow _{X\to Y}\ YXXX\ \Rightarrow _{X\to Y}\ YYXX\ \Rightarrow _{X\to Y}\ YYYX\ \Rightarrow _{X\to Y}\ YYYY}$

${\displaystyle \Rightarrow _{Y\to S}\ SYYY\ \Rightarrow _{Y\to S}\ SSYY\ \Rightarrow _{Y\to S}\ SSSY\ \Rightarrow _{Y\to S}\ SSSS}$

${\displaystyle \Rightarrow _{S\to A}\ ASSS\ \Rightarrow _{S\to A}\ AASS\ \Rightarrow _{S\to A}\ AAAS\ \Rightarrow _{S\to A}\ AAAA}$

${\displaystyle \Rightarrow _{A\to a}\ aAAA\ \Rightarrow _{A\to a}\ aaAA\ \Rightarrow _{A\to a}\ aaaA\ \Rightarrow _{A\to a}\ aaaa}$

At each step of the way, the derivation proceeds by rewriting in cycles. Notice that if at the fifth step SY, we had four options: ${\displaystyle Y\to Z,S\to Z,Y\to S,S\to A}$, the first two of which halt the derivation, as Z cannot be rewritten. In the example, we used ${\displaystyle Y\to S}$ to derive SS, but consider if we had chosen ${\displaystyle S\to A}$ instead. We would have produced the string AS, the options for which are ${\displaystyle Y\to Z}$ and ${\displaystyle A\to Z}$, both of which halt the derivation. Thus with the string SY, and conversely with YS, we must rewrite the Y to produce SS. The same hold for other combinations, so that overall, the ordering forces the derivation to halt, or else proceed by rewriting all Ss to XXs, then all Xs to Ys, then all Ys to Ss, and so on, then finally all Ss to As then all As to as. In this way, a string ${\displaystyle S^{n}}$ can only ever be rewritten as ${\displaystyle A^{n}}$ which produces as, or as ${\displaystyle S^{2n}}$. Starting with n = 0, it should be clear that this grammar only generates the language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$.

An Indian parallel grammar is simply a CFG in which to use a rewrite rule, all instances of the rules non-terminal symbol must be rewritten simultaneously. Thus, for example, given the string aXbYcXd, with two instances of X, and some rule ${\displaystyle X\to w}$, the only way to rewrite this string with this rule is to rewrite it as awbYcwd; neither awbYcXd nor aXbYcwd are valid rewrites in an Indian parallel grammar, because they did not rewrite all instances of X.

Indian parallel grammars can easily produce the language ${\displaystyle \{ww:w\in \{a,b\}^{*}\}}$:

Let ${\displaystyle G=(\{S,A\},\{a,b\},S,\{f,g,h,k\})}$, where

${\displaystyle f=S\to AA}$

${\displaystyle g=A\to aA}$

${\displaystyle h=A\to bA}$

${\displaystyle k=A\to \epsilon }$

Generating aabaab then is quite simple:

${\displaystyle S\Rightarrow _{f}AA\Rightarrow _{g}aAaA\Rightarrow _{g}aaAaaA\Rightarrow _{h}aabAaabA\Rightarrow _{k}aabaab}$

The language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$ is even simpler:

Let ${\displaystyle G=(\{S\},\{a\},S,P)}$, where P consists of

${\displaystyle S\to SS}$

${\displaystyle S\to a}$

It should be obvious, just from the first rule, and the requirement that all instances of a non-terminal are rewritten simultaneously with the same rule, that the number of Ss doubles on each rewrite step using the first rule, giving the derivation steps ${\displaystyle S\Rightarrow S^{2}\Rightarrow S^{4}\Rightarrow S^{8}\Rightarrow ...}$. Final application of the second rule replaces all the Ss with as, thus showing how this simple language can produce the language ${\displaystyle \{a^{2^{n}}:n\geq 0\}}$.

A k-grammar is yet another kind of parallel grammar, very different from an Indian parallel grammar, but still with a level of parallelism. In a k-grammar, for some number k, exactly k non-terminal symbols must be rewritten at every step (except the first step, where the only symbol in the string is the start symbol). If the string has less than k non-terminals, the derivation fails.

A 3-grammar can produce the language ${\displaystyle \{a^{n}b^{n}c^{n}:n\geq 0\}}$, as can be seen below:

Let ${\displaystyle G=(\{S,A,B,C\},\{a,b,c\},S,P)}$, where P consists of:

${\displaystyle S\to ABC}$

${\displaystyle A\to aA}$

${\displaystyle A\to a}$

${\displaystyle B\to bB}$

${\displaystyle B\to b}$

${\displaystyle C\to cC}$

${\displaystyle C\to c}$

With the following derivation for aaabbbccc:

${\displaystyle S\Rightarrow ABC\Rightarrow aAbBcC\Rightarrow aaAbbBccC\Rightarrow aaabbbccc}$

At each step in the derivation except the first and last, we used the self-recursive rules ${\displaystyle A\to aA,B\to bB,C\to cC}$. If we had not use the recursive rules, instead using, say, ${\displaystyle A\to a,B\to bB,C\to cC}$, where one of the rules is not self-recursive, the number of non-terminals would have decreased to 2, thus making the string unable to be derived further because it would have too few non-terminals to be rewritten.

Russian parallel grammars[2] are somewhere between Indian parallel grammars and k-grammars, defined as ${\displaystyle G=(N,T,S,P)}$, where N, T, and S are as in a context-free grammar, and P is a set of pairs ${\displaystyle (A\to w,k)}$, where ${\displaystyle A\to w}$ is a context-free production rule, and k is either 1 or 2. Application of a rule ${\displaystyle p=(A\to w,k)}$ involves rewriting k occurrences of A to w simultaneously.

A scattered context grammar is a 4-tuple ${\displaystyle G=(N,T,S,P)}$ where N, T, and S are defined as in a context-free grammar, and P is a set of tuples called matrixes ${\displaystyle p=(A_{1}\to w_{1},...,A_{n}\to w_{n})}$, where ${\displaystyle n>0}$ can vary according to the matrix. The derives relation for such a grammar is

${\displaystyle x\Rightarrow _{p}y}$ if and only if

${\displaystyle p=(A_{1}\to w_{1},...,A_{n}\to w_{n})\in P}$, and

${\displaystyle x=x_{1}A_{1}x_{2}...x_{n}A_{n}x_{n+1},y=x_{1}w_{1}x_{2}...x_{n}w_{n}x_{n+1}}$, for ${\displaystyle x_{i}\in (N\cup T)^{*}}$

Intuitively, then, the matrixes in a scattered context grammar provide a list of rules which must each be applied to non-terminals in a string, where those non-terminals appear in the same linear order as the rules that rewrite them.

An unordered scattered context grammar is a scattered context grammar in which, for every rule in P, each of its permutations is also in P. As such, a rule and its permutations can instead be represented as a set rather than as tuples.

Scattered context grammars are capable of describing the language ${\displaystyle \{a^{n}b^{n}c^{n}:n\geq 0\}}$ quite easily.

Let ${\displaystyle G=(\{S,A,B,C\},\{a,b,c\},S,\{r_{1},r_{2},r_{3}\})}$, where

${\displaystyle r_{1}=(S\to ABC)}$

${\displaystyle r_{2}=(A\to aA,B\to bB,C\to cC)}$

${\displaystyle r_{3}=(A\to \epsilon ,B\to \epsilon ,C\to \epsilon )}$

Deriving aaabbbccc then is trivial:

${\displaystyle S\Rightarrow _{r_{1}}ABC\Rightarrow _{r_{2}}aAbBcC\Rightarrow _{r_{2}}aaAbbBccC\Rightarrow _{r_{2}}aaaAbbbBcccC\Rightarrow _{r_{3}}aaabbbccc}$