Generating context-free languages using spiking neural P systems with structural plasticity

Abstract

Spiking neural P system (SNP system) is a model of computation inspired by networks of spiking neurons. An SNP system is a network of neurons that can send an object, known as a spike, to each other. Spiking neural P system with structural plasticity (SNPSP system) is a variant of the classical SNP system. SNPSP system that incorporates the ideas of synaptogenesis (creating new synapses) and synaptic pruning (deletion of existing synapses), collectively known as structural plasticity, as features of the model. This gives SNPSP systems the ability to change their own structure/topology. In this work, we use SNPSP systems to generate context-free languages. We create a procedure for constructing an SNPSP system given a context-free grammar in Greibach normal form (GNF). The resulting SNPSP system essentially simulates the way in which a context-free grammar in GNF is used to generate languages. We use modules known as arithmetic-memory modules, also created using SNPSP systems, to perform arithmetic operations which are needed for the simulation.

A Appendix

1.1 A.1 String generation—example

Example

$G = (N=\{A,B\}, T=\{a,b\}, A, P)$ where P contains the following rules: $R_1: A \rightarrow aAB$, $R_2: B \rightarrow bAB$, $R_3: A \rightarrow a$, $R_4: B \rightarrow b$.

The table below shows how the word “aabab” is generated by the algorithm using grammar G.

In iteration 1, ${\overline{N}}=A$, and the popped top symbol is A which means rules $R_1, R_3$ can be applied. After popping the top symbol, the stack is now ${\overline{N}}=\lambda$. $R_1$ is non-deterministically selected and applied. Applying $R_1$ will output the terminal symbol a and will push the symbol B, and then symbol A to the stack which will result in ${\overline{N}}=BA$. The rest of the iterations are shown above. Each iteration performs the Steps 1 and 2 of the algorithm. For each iteration, there is an output terminal symbol. Looking at the ‘Output Symbol’ column in Table 1, you can see that the word “aabab” is generated by the algorithm.

Table 1 String production for aabab

1.2 A.2 Encoding of the stack string—example

$N = \{n_1=A, n_2=B, n_3=C\}$, $x=|N|=3$, $\mathrm{{val}}_3(n_i)=i$ for $1 \le i \le 3$.

1.3 A.3 Arithmetic version of push operation (or string concatenation)—example

We can use strings in Table 2. The size of the alphabet N is $x=3$, string ABC is encoded as $123_4$ (in base $x+1=4$) and string AA is encoded as $11_4$. If we let ${\overline{N}} = ABC$ and $N'=AA$, then ${\overline{N}}N'=ABCAA$. If we encode ${\overline{N}}N'=ABCAA$ as described in Eq. 2, then (note: $x+1=4_{10}$ or $x+1=10_4$)

$$\begin{aligned} \mathrm{{val}}_3(ABCAA)_{10} \, = \, & {} \mathrm{{val}}_3(A)\cdot 4^4 + \mathrm{{val}}_3(B)\cdot 4^3 + \mathrm{{val}}_3(C)\cdot 4^2 + \mathrm{{val}}_3(A)\cdot 4^1 + \mathrm{{val}}_3(A)\cdot 4^0 \\ \mathrm{{val}}_3(ABCAA)_{10}= & {} 1\cdot 4^4 + 2\cdot 4^3 + 3\cdot 4^2 + 1\cdot 4^1 +1\cdot 4^0 = 437_{10} \end{aligned}$$

The encoding $\mathrm{{val}}_3(ABCAA)_{10}=437_{10}$ is calculated using base 10. In base $x+1=4$, it is written as $12311_4$. It is easier to visualize how the encoding works when the result is written in base $x+1$, since for every symbol in the string, there is a corresponding ‘digit’ in the encoding when written in base $x+1$. In base $x+1=4$, the resulting encoding $\mathrm{{val}}_3(ABCAA)$ is the concatenation of the digits of $\mathrm{{val}}_3(ABC)=123_4$ and digits of $\mathrm{{val}}_3(AA)=11_4$ which is $12311_4$. But since concatenation is an operation on strings and the encodings are numbers, we use Eq. 7 for $p'_1$ to define arithmetically this digit concatenation process. Using $p'_1$, $\mathrm{{val}}_3(ABCAA)$ can be calculated as $p'_1(\mathrm{{val}}_3(ABC), \mathrm{{val}}_3(AA))$:

$$\begin{aligned} p'_1(\mathrm{{val}}_3(ABC), \mathrm{{val}}_3(AA)) \,= \,& {} \mathrm{{val}}_3(ABC)(10_4)^{|AA|} + \mathrm{{val}}_x(AA) \\ p'_1(\mathrm{{val}}_3(ABC), \mathrm{{val}}_3(AA))= & {} 123_4 \cdot (10_4)^{2_4} + 11_4 = 12300_4 + 11_4 = 12311_4 \end{aligned}$$

Table 2 String encoding examples

1.4 A.4 String generation using arithmetic version of stack operations—example

Let $G = (N=\{A,B,C\}, T=\{a,b,c\}, A, P)$ where P contains the following rules: $R_1: A \rightarrow aABB$, $R_2: B \rightarrow bBBC$, $R_3: A \rightarrow a$, $R_4: B \rightarrow b$, $R_5: C \rightarrow c$.

The string aabbbcb is generated by grammar G as follows:

$A \xrightarrow []{R_1} aABB \xrightarrow []{R_3} aaBB \xrightarrow []{R_2} aabBBCB \xrightarrow []{R_4} aabbBCB \xrightarrow []{R_4} aabbbCB \xrightarrow []{R_5} aabbbcB \xrightarrow []{R_4} aabbbcb$

Starting form the axiom symbol A, one applicable rule is non-deterministically selected and applied to the first (left-most) non-terminal symbol. One rule is applied at any given time. Since grammar G is in Greibach normal form, when a rule is applied, only one terminal symbol is generated at a time. The string is generated from left to right.

We note a difference in conventions used in the string generation above and the string generation using the stack algorithm. In string generation above, for example in the step: $aaBB \xrightarrow []{R_2} aabBBCB$, the terminal symbols are generated from left to right, applying the rules first on the left-most non-terminal symbol which in this step is B. When $R_2$ is applied to B, terminal symbol b is generated and non-terminal symbols BBC are generated. In the stack algorithm, stack string ${\overline{N}}$ stores the non-terminal symbols. In this step, ${\overline{N}}=BB$ but the top of the stack is the right-most symbol of ${\overline{N}}$. When $R_2$ is applied, ${\overline{N}}=B$ since the top symbol B was popped, and the string CBB is pushed to the stack making the stack string ${\overline{N}}=BCBB$. The stack algorithm also generates the string from left to right similar to the normal derivation, the only difference is on the convention of how the stack string is written. The left-most non-terminal symbol in the generated string corresponds to the top (right-most) symbol of the stack.

This convention in writing the stack string is used when the stack string is encoded as a number the top symbol of the stack will be the least significant digit of the encoded number, i.e., stack string ${\overline{N}}=ABCABC$, $val_3(ABCABC)=123123_4$, the top of symbol of the stack is C, and the top symbol encoding is the least significant digit $3_4$. The least significant digit of $val_x({\overline{N}})$ is easier to calculate compared to its most significant digit.

Table 3 shows the seven iterations of the algorithm when generating the string aabbbcb. The third column shows the encoding $\mathrm{{val}}_3({\overline{N}})$ in base $x+1=4$ of the stack string ${\overline{N}}$. The value of $p'_2(\mathrm{{val}}_3({\overline{N}}))$ is the least significant digit of $val_3({\overline{N}})$ which corresponds to the top symbol of the stack. The value of $p'_3(\mathrm{{val}}_3({\overline{N}}))$ is the encoding of the new stack after removing the top symbol of the stack. $N'$ is the reverse string of non-terminal symbols of a production rule, e.g., For $R_1: A \rightarrow aABB$, $N'=BBA$ and for $R_2: B \rightarrow bBBC$, $N'=CBB$. Noting again, $N'$ is the reverse of the actual non-terminal substring because of the convention used in the stack algorithm (right-most symbols being first to be processed, top of the stack). $\mathrm{{val}}_3(N')$ is the encoding of $N'$. $\mathrm{{val}}_3(N')$ is what is pushed, using $p'_1$ to the new stack $p'_3(\mathrm{{val}}_3({\overline{N}}))$. The resulting stack is $p'_1( p'_3(\mathrm{{val}}_3({\overline{N}})),\mathrm{{val}}_3(N'))$. Column 6 shows the generated terminal symbol per iteration.

Table 3 String generation for aabbbcb