Vector Symbolic Architectures for Context-Free Grammars

Vector symbolic architectures (VSA) are a viable approach for the hyperdimensional representation of symbolic data, such as documents, syntactic structures, or semantic frames. We present a rigorous mathematical framework for the representation of phrase structure trees and parse trees of context-free grammars (CFG) in Fock space, i.e. infinite-dimensional Hilbert space as being used in quantum field theory. We define a novel normal form for CFG by means of term algebras. Using a recently developed software toolbox, called FockBox, we construct Fock space representations for the trees built up by a CFG left-corner (LC) parser. We prove a universal representation theorem for CFG term algebras in Fock space and illustrate our findings through a low-dimensional principal component projection of the LC parser state. Our approach could leverage the development of VSA for explainable artificial intelligence (XAI) by means of hyperdimensional deep neural computation.


Introduction
Claude E. Shannon, the pioneer of information theory, presented in 1952 a "maze-solving machine" as one of the first proper technical cognitive systems [1]. 1 It comprises a maze in form of a rectangular board partitioned into discrete cells that are partially separated by removable walls, and a magnetized "mouse" (nicknamed "Theseus", after the ancient Greek hero) as a cognitive agent.The mouse possesses as an actuator a motorized electromagnet beneath the maze board.The magnet pulls the mouse through the maze.Sensation and memory are implemented by a circuit of relays, switching their states after encounters with In Shannon's mouse-maze system, the motor (the actuator) pulls the mouse along a path until it bumps into a wall which is registered by a sensor.This perception is stored by switching a relay, subsequently avoiding the corresponding action.The behavior control prescribes a certain maze cell where the agent may find a "piece of cheese" as a goal.When the goal is eventually reached, no further action is necessary.In a first run, the mouse follows beim Graben et al.
an irregular path according to a trial-and-error strategy, while building up a memory trace in the relay array.In every further run, the successfully learned path is pursued at once.However, when the operator modifies the arrangement of walls, the previously learned path becomes useless and the agent has to learn from the very beginning.Therefore, Shannon [1, p. 1238] concludes: The maze-solver may be said to exhibit at a very primitive level the abilities to (1) solve problems by trial and error, (2) repeat the solutions without the errors, (3) add and correlate new information to a partial solution, (4) forget a solution when it is no longer applicable.In Shannon's original approach, the mouse learns by trial-and-error whenever it bumps into a wall.More sophisticated cognitive dynamic systems should be able to draw logical inferences and to communicate either with each other or with an external operator, respectively [4].This requires higher levels of mental representations such as formal logics and grammars.Consider, e.g., the operator's utterance: the mouse ate cheese (1) (note that symbols will be set in typewriter font in order to abstract from their conventional meaning in the first place).In the PAC described in Fig. 1, the acoustic signal has firstly to be analyzed in order to obtain a phonetic string representation.For understanding its meaning, the agent has secondly to process the utterance grammatically through syntactic parsing.Finally, the syntactic representation, e.g. in form of a phrase structure tree, must be interpreted as a semantic representation which the agent can ultimately understand [53].
Depending upon such understanding, the agent can draw logical inferences and derive the appropriate behavior for controlling the actuators.In case of verbal behavior [5], the agent therefore computes an appropriate response, first as a semantic representation, that is articulated into a syntactic and phonetic form and finally synthesized as an acoustic signal.In any case, high-level representations are symbolic and their processing is rule-driven, in contrast to low-level sensation and actuation where physical signals are essentially continuous.
Originally, Shannon used an array of relays as the agent's memory.This has later been termed the "learning matrix" by Steinbuch and Schmitt [6].Learning matrices and vector symbolic architectures (VSA) provide a viable interface between hierarchically organized symbolic data structures such as phrase structure trees or semantic representations and continuous state space approaches as required for neural networks.Beginning with seminal studies by Smolensky [7] and Mizraji [8], and later pursued by Plate [9], beim Graben and Potthast [10], and Kanerva [11] among many others, those architectures have been dubbed VSA by Gayler [12].
In a VSA, symbols and variables are represented as filler and role vectors of some underlying linear spaces, respectively.When a symbol is assigned to a variable, the corresponding filler vector is "bound" to the corresponding role vector.Different filler-role bindings can be "bundled" together to form a data structure, such as a list, a frame, or a table of a relational data base.Those structures can be recursively bound to other fillers and further bundled together to yield arbitrarily complex data structures.
VSA have recently been employed for semantic spaces [13], logical inferences [14,15], data base queries [16], and autoassociative memories [17,18].Wolff et al. [19] developed a VSA model for cognitive representations and their induction in Shannon's mouse-maze system.In this article, we focus to the dashed region in Fig. 1, by elaborating earlier approaches for VSA language processors [20,21,22,23,24].We present rigorous proofs for the vector space representations of context-free grammars (CFG) and push-down automata [25].To this end, we suggest a novel normal form for CFG, allowing to express CFG parse trees as terms over a symbolic term algebra.Rule-based derivations over that algebra are then represented as transformation matrices in Fock space [26,27].
Our approach could lead to the development of new machine learning algorithms for training neural networks as rule-based symbol processors.In contrast to black-box deep neural network models, our method is essentially transparent and hence explainable [28].

Methods
We start from a symbolic, rule-based system that can be described in terms of formal grammar and automata theory.Specifically, we chose context-free grammars (CFG) and pushdown automata as their processors here [25].In the second step, we reformulate these languages through term algebras and their processing through partial functions over term algebras.We introduce a novel normal form for CFG, called term normal form, and prove that any CFG in Chomsky normal form can be transformed into term normal form.Finally, we introduce a vector symbolic architecture by assigning basis vectors of a high-dimensional linear space to the respective symbols and their roles in a phrase structure tree.We suggest a recursive function for mapping CFG phrase structure trees onto representation vectors in Fock space and prove a representation theorem for the partial rule-based processing functions.

Context-free Grammars
Consider again the simple sentence (1) as a motivating example.According to linguistic theory, sentences such as (1) exhibit a hierarchical structure, indicating a logical subjectpredicate relationship.In (1) "the mouse" appears as subject and the phrase "ate cheese" as the predicate, which is further organized into a transitive verb "ate" and its direct object "cheese".The hierarchical structure of sentence (1) can therefore be either expressed through regular brackets, as in ( 2) or, likewise as a phrase structure tree as in Fig.In Fig. 2 every internal node of the tree denotes a syntactic category: S stands for "sentence", NP for "noun phrase", the sentence's subject, VP for "verbal phrase", the predicate, D for "determiner", N for "noun", and V for "verb".
The phrase structure tree Fig. 2 immediately gives rise to a context-free grammar (CFG) by interpreting every branch as a rewriting rule in Chomsky normal form [29,25] S → NP VP (3a) where one distinguishes between syntactical rules (3a -3c) and lexical rules (3d -3g), respectively.More abstractly, a CFG is given as a quadruple G = (T, N, S, R), such that in Context-free grammars can be processed by push-down automata [25].Regarding psycholinguistic plausibilty, the left-corner (LC) parser is particularly relevant because inputdriven bottom-up and expectation-driven top-down processes are tightly intermingled with each other [30].An LC parser possesses, such as any other push-down automaton, two memory tapes: firstly a working memory, called stack, operating in a last-in-first-out (LIFO) fashion, and an input tape storing the sentence to be processed.
In the most simple cases, when a given CFG does not contain ambiguities (as in (3a -3g) for our example (1)), an LC parser can work deterministically.The LC parsing algorithm operates in four different modes: i) if nothing else is possible and if the input tape is not empty, the first word of the input is shifted into the stack; ii) if the first symbol in the stack is the left corner of a syntactic rule, the first stack symbol is rewritten by a predicted category (indicated by square brackets in Tab. 1) followed by the left-hand side of the rule (project); iii) if a category in the stack was correctly predicted, the matching symbols are removed from the stack (complete); iv) if the input tape is empty and the stack only contains the start symbol of the grammar, the automaton moves into the accepting state; otherwise, syntactic language processing had failed.Applying the LC algorithm to our example CFG leads to the symbolic process shown in Tab.
Table 1 Left-corner parser processing the example sentence (1).The stack expands to the left.
The left-corner parser shown in Tab. 1 essentially operates autonomously in modes project, complete and accept, but interactively in shift mode.Thus, we can significantly simplify the parsing process through a mapping from one intermediary automaton configuration to another one that is mediated by the interactively shifted input word [21,31].Expressing the configurations as temporary phrase structure trees yields then the symbolic computation in Fig. 3.According to our previous definitions, the states of the processor are the automaton configurations in Tab. 1 or the temporary phrase structures trees in Fig. 3, that are both interpretable in terms of LC parsing and language processing for an informed expert observer.Moreover, the processing steps in the last column of Tab. 1 and also the interactive mappings Fig. 3 are understandable and thereby explainable by the observer.In principle, one could augment the left-corner parser with a "reasoning engine" [28] that translates the formal language used in those symbolic representations into everyday language.The result would be something like the (syntactic) "meaning" w of a word w that can be regarded as the operator mapping a tree in Fig. 3 to its successor.This interactive interpretation of meaning is well-known in dynamic semantics [33,34,35,36].Therefore, symbolic AI is straightforwardly interpretable and explainable [28].

Algebraic Description
In order to prepare the construction of a vector symbolic architecture (VSA) [32,8,9,12,11,10] in the next step, we need an algebraically more sophisticated description.This is provided by the concept of a term algebra [23,29].A term algebra is defined over a signature Σ = (F, rank) where F is a finite set of function symbols and rank : F → N 0 is an arity function, assigning to each symbol f ∈ F an integer indicating the number of arguments that f has to take.
To apply this idea to a CFG, we introduce a new kind of grammar normal form that we call term normal form in the following.A CFG G = (T, N, S, R) is said to be in term normal It can be easily demonstrated that every CFG can be transformed into a weakly equivalent CFG in term normal form, where weak equivalence means that two different grammars derive the same context-free language.A proof is presented in Appendix 6.1.
Obviously, the rules (3a -3c) of our example above are already in term normal form, simply because they are not ambiguous.Thus, we define a term algebra by regarding the set of variables V = N ∪ T as signature with arity function rank : V → N 0 such that i) rank(a) = 0 for all a ∈ T , i.e. terminals are nullary symbols and hence constants; ii) rank(A) = |γ| for categories A ∈ N, that are expanded through rules A → γ.Moreover, when G is given in Chomsky normal form, for all categories A ∈ N appearing exclusively in lexical rules rank(A) = 1, i.e. lexical categories (D, N, V) are unary functions.Whereas, rank(A) = 2 for all categories A ∈ N that appear exclusively in syntactic rules, which are hence binary functions.
For a general CFG G in term normal form, we define the term algebra T(G) inductively.i) every terminal symbol a ∈ T is a term, a ∈ T(G).ii) Let A ∈ N be a category with rank(A) = k and let t 0 , . . .,t k−1 ∈ T(G) be terms, then A(t 0 , . . .,t k−1 ) ∈ T(G) is a term.Ad-ditionally, we want to describe LC phrase structure trees as well.To this end, we extend the signature by the predicted categories P = {[N], [VP]}, that are interpreted as constants with rank(C) = 0 for C ∈ P. The enlarged term algebra is denoted by T LC (G).We also allow for / 0 ∈ T LC (G).
In the LC term algebra T LC (G), we encode the tree of step 1 in Fig. 3 (beginning with the empty tree t 0 = / 0 in step 0) as term as the term representation of the succeeding step 2 in Fig. 3.
Next, we define several partial functions over T LC (G) as follows [23,40].
Here, the function cat : T LC (G) → N yields the category, i.e. the function symbol A of the term A(t 0 , . . .,t k ) ∈ T LC (G).The functions ex i : T LC (G) → T LC (G) for term extraction and cons k : N × T LC (G) k+1 → T LC (G) as term constructor are defined only partially, when By means of the term transformations (6a -6c) we can express the action of an incrementally and interactively shifted word a ∈ T through a term operator a : T LC (G) → T LC (G).For the transition from, e.g., LC tree 1 to LC tree 2 in Fig. 3 we obtain mouse (t 1 ) = cons 2 (S, cons 2 (cat(t 1 ), ex 0 (t 1 ), N(mouse)), [VP]) = t 2 .
Therefore, the (syntactic) meaning of the word "mouse" is its impact on the symbolic term algebra.

Vector Symbolic Architectures
In vector-symbolic architectures (VSA) [32,8,9,12,11,10] hierarchically organized complex data structures are represented as vectors in high dimensional linear spaces.The composition of these structures is achieved by two basic operations: binding and bundling.While bundling is commonly implemented as vector superposition, i.e. addition, different VSA realize binding in particular ways: originally through tensor products [32,7,8,37], through circular convolution in reduced holographic representations (HRR) [9], through XOR spatter code [38] or through Hadamard products [39].While HRR, spatter code, Hadamard products or a combination of tensor products with nonlinear compression [40] are lossy representations that require a clean-up module (usually an attractor neural network, cf.[11]), tensor product representations of basis vectors are faithful, thereby allowing interpretable and explainable VSA [28].
Coming back to our linguistic example, we construct a homomorphism ψ : T LC (G) ∪ N → F from the term algebra unified with its categories N to a vector space F in such a way, that the structure of the transformations (6a -6c) is preserved.The resulting images ψ(t) for terms t ∈ T LC (G) become vector space operators, i.e. essentially matrices acting on F .
Again, we proceed inductively.First we map the symbols in T LC (G)∪N onto vectors.To each atomic symbol s ∈ T ∪ N ∪ P we assign a so-called filler basis vector |s = ψ(s) ∈ F , calling the subspace V F = span(ψ(T ∪ N ∪ P)) the filler space.Its dimension n = dim V F corresponds to the number of atomic symbols in T ∪ N ∪ P, which is n = 13 in our example.
Let further m = max({|γ| | (A → γ) ∈ R}) be the length of the largest production of grammar G.Then, we define m + 1 so-called role vectors |i , spanning the role space V R = span({|i | 0 ≤ i ≤ m}).Note that we employ the so-called Dirac notation from quantum mechanics that allows a coordinate-free and hence representation-independent description here [41].Then, the role |0 denotes the 1st daughter node, |1 the 2nd daugther and so on, Let A(t 0 , . . .,t k ) ∈ T LC (G) be a term.Then, we define the tensor product representation of A(t 0 , . . .,t k ) ∈ T LC (G) in vector space F recursively as follows As a shorthand notation, we suggest the Dirac expression Here the symbol "⊗" refers to the (Kronecker) tensor product, mapping two vectors onto another vector, in contrast to the dyadic (outer) tensor product, which yields a matrix, which is a vector space operator.In addition, "⊕" denotes the (outer) direct sum that is mandatory for the superposition of vectors from spaces with different dimensionality.
Obviously, the (in principle) infinite recursion of the mapping ψ leads to an infinitedimensional representation space that is known as Fock space from quantum field theory [26,27,10,42].
In quantum field theory, there is a distinguished state |0 = 0, the vacuum state, spanning a one-dimensional subspace, the vacuum sector that is isomorphic to the underlying number field.According to (10), this sector is contained in the subspace spanned by filler and role spaces, V F ⊕ V R .Therefore, we could represent the empty tree in Fig. 3 by an arbitrary role; a suitable choice is the mother role ψ( / 0) = |m ∼ = |0 , hence symbolizing the vacuum state.
Using the tensor product representation (8), we can recursively compute the images of our example terms above.For (4) we obtain where we used the compressed Dirac notation |a ⊗ |b = |ab in the last steps.The last line is easily interpretable in terms of phrase structure: It simply states that NP occupies the root of the tree, D appears as its immediate left daughter, the is the left daughter's left daughter and a leave, and finally [N] is a leave bound to the right daughter of the root.Note that the Dirac kets have to be interpreted from the right to the left (reading the arabic way).The vector |t 1 belongs to a Fock subspace of dimension where n = dim(V F ), m = dim(V R ) and p the embedding depth in the phrase structure tree step 1 of Fig. 3.This leads to q 1 = 172 for |t 1 .
Similarly, we get for ( 5) where we have again utilized the more intuitive branching notation in the last line which can be straightforwardly interpreted in terms of tree addresses as depicted in Fig. 3 (step 2).
Computing the dimension of the respective Fock subspace according to (12) yields q 2 = 523 for |t 2 .
beim Graben et al.
In Fock space, the interactive and incremental action of a word a ∈ T is then represented as a matrix operator a ψ : F → F .For the transition from ( 4) to ( 5) we obtain In order to prove ψ a homomorphism, we define the following linear maps on F .
here, 1 denotes the unit operator (i.e. the unit matrix) and the Dirac "bra" vectors k| are linear forms from the dual role space V * R that are adjoined to the role "ket" vectors |k such that i|k = δ ik with Kronecker's By means of these homomorphisms we compute the meaning of "mouse" as Fock space operator through Inserting (15a -15c) yields where we have expanded |N(mouse) as in (13) above.Note that the meaning of "mouse" crucially depends on the given state |t 1 subjected to the operator mouse ψ , making meaning highly contextual.This is an important feature of dynamic semantics as well [33,34,35,36].

Results
The main result of this study is a Fock space representation theorem for vector symbolic architectures of context-free grammars that follows directly from the definitions (15a -15c) and is proven in Appendix 6.2.
The tensor product representation ψ : T LC (G) ∪ N → F is a homomorphism with respect to the term transformations (6a -6c).It holds For the particular example discussed above, we obtain the Fock space trajectory in Tab. 2.Moreover, we present the complete Fock space LC parse generated by FockBox which is a MATLAB toolbox provided by Wolff et al. [43] as its three-dimensional projection after principal component analysis (PCA [21,23,43]) in Fig. 4 as illustration.

Discussion
In this article we developed a representation theory for context-free grammars and pushdown automata in Fock space as a vector symbolic architecture (VSA).We presented rigorous proofs for the representations of suitable term algebras.To this end, we suggested a novel normal form for CFG allowing to express CFG parse trees as terms over a symbolic term algebra.Rule-based derivations over that algebra are then represented as transformation matrices in Fock space.
Motivated by a seminal study of Shannon [1] on cognitive dynamic systems [3], our work could be of significance for levering research on cognitive user interfaces (CUI) [2,44,45,46].Such systems are subject of ambitious current research.Instead of using keyboards and displays as input-output interfaces, users pronounce requests or instructions to a device as spoken language and listen its uttered responses.To this aim, state-of-theart language technology scans the acoustically analyzed speech signal for relevant keywords that are subsequently inserted into semantic frames [47] to interpret the user's intent.This slot filling procedure [48,49,50] is based on large language corpora that are evaluated by machine learning methods, such as deep learning of neural networks [50].The necessity to overcome traditional slot filling techniques by proper semantic analyses technologies has already been emphasized by Allen [51].His research group trains semantic parsers from large language data bases such as WordNet or VerbNet that are constrained by hand-crafted expert knowledge and semantic ontologies [48,52].
Another road toward realistic CUI systems is the development of utterance-meaning transducers (UMT) that map syntactic representations obtained from the speech signal onto semantic representations in terms of feature value relations (FVR) [53,45].This is achieved through a perception action cycle, comprising the three components: perception, action and behavior control.The perception module transforms the input from the signal layer to the semantic symbolic layer, the module for behavior control solves decision problems based on semantic information and computes appropriate actions.Finally, the action module executes the result by producing acoustic feedback.Behavior control can flexibly adapt to user's demands through reinforcement learning.
For the implementation of rule-based symbolic computations in cognitive dynamic systems, such as neural networks, VSA provide a viable approach.Our results contribute a formally sound basis for this kind of future research and engineering.

Conclusion
We reformulated context-free grammars (CFG) through term algebras and their processing through push-down automata by partial functions over term algebras.We introduced a novel normal form for CFG, called term normal form, and proved that any CFG in Chomsky normal form can be transformed into term normal form.Finally, we introduced a vector symbolic architecture (VSA) by assigning basis vectors of a high-dimensional linear space to the respective symbols and their roles in a phrase structure tree.We suggested a recursive function for mapping CFG phrase structure trees onto representation vectors in Fock space and proved a representation theorem for the partial rule-based processing functions.
We illustrated our findings by an interactive left-corner parser and used FockBox, a freely accessible MATLAB toolbox, for the generation and visualization of Fock space VSA.Our approach directly encodes symbolic, rule-based knowledge into the hyperdimensional computing framework of VSA and can thereby supply substantial insights into the future development of explainable artifical intelligence (XAI).Definition 2 (Chomsky Normal Form) According to [25] a CFG G = (T, N, S, R) is said to be in Chomsky normal form iff every production r ∈ R is one of It is a known fact, that for every CFG G there is an equivalent CFG G in Chomsky normal form [25].It is also known that if G does not produce the empty string -absence of production (19c) -then there is an equivalent CFG G in Chomsky reduced form [25].
beim Graben et al.
Theorem 1 For every CFG G = (T, N, S, R) not producing the empty string there is an equivalent CFG G in term normal form.
Proof Let G = (T, N, S, R) be a CFG not producing the empty string.Let G = (T, N , S, R ) be the equivalent CFG in Chomsky reduced form and D ⊆ N be the set of all nonterminals from G which have productions of both forms (20a) and (20b).
We establish term normal form by applying the following transformations to G : Finally, we remove all rules L A from R .Finally, we remove all rules R A from R . 5. Finally, we remove D from N .

We immediately deduce
Corollary 2 For every CFG G only producing strings of either exactly length 1 or at least length 2 there is an equivalent CFG G in term normal form which is also in Chomsky normal form.
Proof We handle the two cases separately.
Case 1 Let G be a CFG producing strings of exactly length 1.Since G does not produce the empty string there is an equivalent CFG G in Chomsky reduced form where every rule is of form (20b) and the only nonterminal being the start symbol.Obviously, G is in Chomsky normal form and also in term normal form.
Case 2 Let G be a CFG producing strings of at least length 2. Since G does not produce the empty string there is an equivalent CFG in Chomsky reduced form and from corollary 1 follows that there is an equivalent CFG in Chomsky normal form.Applying the construction from theorem 1 to this CFG leads to a CFG G in term normal formal.Since G does not produce strings of length 1 step 4 is omitted by the construction and G stays in Chomsky normal form.

Proof of Representation Theorem
The proof of the Fock space representation theorem for vector symbolic architectures follows from direct calculation using the definition of the tensor product representation (9).

Fig. 1
Fig. 1 Hierarchical perception-action cycle (PAC) for a cognitive dynamic system.The scope of the present paper is indicated by the dashed boundary.
our example T = {the, mouse, ate, cheese} is the set of words or terminal symbols, N = {S, NP, VP, D, N, V} is the set of categories or nonterminal symbols, S ∈ N is the distinguished start symbol, and R ⊂ N × (N ∪ T ) * is a set of rules.A rule r = (A, γ) ∈ R is usually written as a production r : A → γ where A ∈ N denotes a category and γ ∈ (N ∪ T ) * a finite string of terminals or categories of length n = |γ|.
until the last daughter |m − 1 .The remaining role |m bounds the mother node in the phrase structure trees of grammar G.In our example, because G has Chomsky normal form, we have m = 2 = dim V R − 1 such that there are three roles for positions in a binary branching tree: left daughter |0 , right daughter |1 , and mother |2 .For binary trees, we also use a more intuitive symbolic notation: left daughter |/ , right daughter |\ , and mother |∧ .

Fig. 4
Fig. 4 Principal component (PC) projection of the LC parser's Fock space representation.Shown are the first three PCs.

beim 6 Appendix 6 . 1
Graben et al. 53.L. Karttunen.Features and values.In Proceedings of the 10th International Conference on Computational Linguistics, pages 28 -33, Stroudsburg (PA), 1984.Association for Computational Linguistics (ACL).Proof of Term Normal Form Definition 1 (Context-Free Grammer) A context-free grammar (CFG) is a quadruple G = (T, N, S, R) with a set of terminals T , a set of nonterminals N, the start symbol S ∈ N and a set of rules R ⊆ N × (N ∪ T ) * .A rule r = (A, γ) ∈ R is usually written as a production r : A → γ.

1 . 2 .
For every nonterminal A ∈ D let R A = {(A, BC) ∈ R | B,C ∈ N } be the rules corresponding to productions of form (20a) and R A = {(A, a) ∈ R | a ∈ T } be the rules corresponding to productions of form (20b).We add (a) new nonterminals A and A , (b) a new rule (A , BC) for every rule (A, BC) ∈ R A and (c) a new rule (A , a) for every rule (A, a) ∈ R A .Finally, we remove all rules R A ∪ R A from R .For every nonterminal A ∈ D let L A = {(X, AY ) ∈ R | X,Y ∈ N } be the set of rules where A appears at first position on the right-hand side.For every rule (X, AY ) ∈ L A we add (a) a new rule (X, A Y ) and (b) a new rule (X, A Y ).

3 .
For every nonterminal A ∈ D let R A = {(X,Y A) ∈ R | X,Y ∈ N }be the set of rules where A appears at second position on the right-hand side.For every rule (X,Y A) ∈ R A we add (a) a new rule (X,Y A ) and (b) a new rule (X,Y A ).

4 .
If S ∈ D then we add (a) a new start symbol S 0 , (b) a new rule (S 0 , S ) and (c) a new rule (S 0 , S ).

Table 2
Fock space representation of LC parser processing the example sentence (1).