Matrix representation and simulation algorithm of spiking neural P systems with structural plasticity

Abstract

In this paper, we create a matrix representation for spiking neural P systems with structural plasticity (SNPSP, for short), taking inspiration from existing algorithms and representations for related variants. Using our matrix representation, we provide a simulation algorithm for SNPSP systems. We prove that the algorithm correctly simulates an SNPSP system: our representation and algorithm are able to capture the syntax and semantics of SNPSP systems, e.g. plasticity rules, dynamism in the synapse set. Analyses of the time and space complexity of our algorithm show that its implementation can benefit using parallel computers. Our representation and simulation algorithm can be useful when implementing SNPSP systems and related variants with a dynamic topology, in software or hardware.

Theorem proofs

Proof for Theorem 1

By definition, $Rule ^{(k)} = ( Fi ^{(k)}, Ti ^{(k)}, os^{(k)}, sp^{(k)})$. First, given that the input $Conf ^{(k-1)}$ is of the previous time step (fed into the function as $Conf ^{(k)}$), we first increment k at Line 1 for appropriate usage in the resulting rule node. Thus, we know that the newRules() constructor at Line 18 is of the right time step. Line 4 evaluates a formula and assigns it to a temporary variable Sp, for spikes. The formula consists of two parts, the multiplication and the subtraction. It goes as follows:

$$\begin{aligned} Sp&= \left( C^{(k-1)} \times Sr _{\mathcal{R}}^T\right) - P_{\mathcal{R}} \\&= \left( \Big [c_i^{(k-1)}\Big ]_m \times \Big [sr_{{\mathcal{R}},i,j}\Big ]_{m \times {r_{{\mathcal{R}}}}} \right) - \Big [p_{{\mathcal{R}},i}\Big ]_{{r_{{\mathcal{R}}}}} = \left( \bigg [ \sum _i{c_i^{(k-1)} sr_{{\mathcal{R}},i,j}} \bigg ]_{{r_{{\mathcal{R}}}}} \right) - \bigg [p_{{\mathcal{R}},i}\bigg ]_{{r_{{\mathcal{R}}}}} \end{aligned}$$

Since $sr_{{\mathcal{R}},i,j} = 1$ if rule ${r_{{\mathcal{R}},i}}$ belongs to neuron $\sigma _j$ (0 otherwise), and $c_i^{(k)}$ is the number of spikes in neuron $\sigma _i$ at time k, we have

$$\begin{aligned} c_i^{(k-1)} sr_{{\mathcal{R}},i,j} = {\left\{ \begin{array}{ll} c_i^{(k-1)}, &{} {r_{{\mathcal{R}},j}}\in R_i; \\ 0, &{} {\text {otherwise.}} \end{array}\right. } \end{aligned}$$

Also noting that rules can only be associated with one neuron, we can then conclude that $\sum _i{c_i^{(k-1)} sr_{{\mathcal{R}},i,j}}$ is the number of spikes in the source neuron of rule ${r_{{\mathcal{R}},j}}$. We let $rsp_{{\mathcal{R}},i}$ be this number. Now that we know each rule’s respective source neuron spike count; we can now use the P and Q vectors to check compatibility with the rule’s respective regular expression. Thus

$$\begin{aligned} Sp&= \left( \bigg [ \sum _i{c_i^{(k-1)} sr_{{\mathcal{R}},i,j}} \bigg ]_{{r_{{\mathcal{R}}}}} \right) - \bigg [p_{{\mathcal{R}},i}\bigg ]_{{r_{{\mathcal{R}}}}} \\&= \Big [ rsp_{{\mathcal{R}},i} \Big ]_{{r_{{\mathcal{R}}}}} - \Big [p_{{\mathcal{R}},i}\Big ]_{{r_{{\mathcal{R}}}}} = \Big [ rsp_{{\mathcal{R}},i} - p_{{\mathcal{R}},i}\Big ]_{{r_{{\mathcal{R}}}}} \end{aligned}$$

With s being the current spike count of a certain neuron, we need to match $a^s$ with $a^p(a^q)*=a^{p+qn}$, and thus we need to make sure $s=p+qn$ for some nonnegative integers p,q, and n. So we first subtract p in Line 4, and check for qn in the if clause of Line 7. There are two cases for $a^s$ to match the regular expression. First, if there is a non-zero q for the rule, there is no problem using $Sp_i \mathbf mod q_{{\mathcal{R}},i} = 0$ (so long as $Sp_i$ is not negative, in which case $rsp_{{\mathcal{R}},i} - p_{{\mathcal{R}},i} = s - p < 0$). The other case would be if $q=0$, in which case the regular expression is of the form $a^p$. Thus, $p+qn=p$, a constant, and so $s=p+qn$ can only be satisfied if $s-p = rsp_{{\mathcal{R}},i} - p_{{\mathcal{R}},i} = 0$. If the regular expression is matched, $fi_{\mathcal{R}},i^{(k)} = 1$; otherwise, $= 0$. Since the loop of Line 6 iterates over all the rules of type ${\mathcal{R}}$, and that ${\mathcal{R}}$ goes through both ${\mathcal{P}}$ and ${\mathcal{S}}$ (Line 3), these two loops go over all the rules. Thus, $Fi ^{(k)}$ now tells us which rules have matched their regular expressions and can fire.

$os^{(k)}$ would by default copy the value from the previous time step, $os^{(k)}$, while $sp^{(k)}$ would stay at 0. The former would only increase and the latter be set to 1 if an output spike was discovered to be sent to the environment at time k. This condition is checked by the if clause at Line 9, which would only be reached if rule ${r_{{\mathcal{R}},i}}$ were to fire at time k for the given values of ${\mathcal{R}}$ and i. Thus, we only need to check if this rule sent an output spike. Since only spiking rules can send spikes to the environment, the condition at Line 9 should check if the given rule was a spiking rule (${\mathcal{R}}={\mathcal{S}}$) and if the current rule belonged to the output neuron ($Sr_{{\mathcal{S}},out,i} = 1$). Thus, $os^{(k)}$ and $sp^{(k)}$ are now computed correctly.

Lastly, the timer matrix $Ti ^{(k)}$ would only be touched in the for loop of Line 12. For each plasticity rule, we first check if the rule already fired at the previous time step (Line 13) and is still executing at the current time step (as with the ± and $\mp$ rules). This could be checked by looking for a 1 in the primed timers of the said rule from the previous time step ($Ti_{i'}^{(k-1)}$), since the timers have already counted down after initial rule firing. $fi_{{{\mathcal{P}}},i}^{(k)}$ is simply marked as 0 since the rule is not allowed to fire anew if it is still executing, and just copies the previous primed timers onto the current unprimed timers. Otherwise, if the rule is not to execute a second operation at the current time step, we check if it fired anew at the current time step (Line 9). Since ${ Fi }_{{\mathcal{R}}}^{(k)}$ now shows which rules are applicable (unless ongoing execution), we can now be sure that the rules will be applied at time step k and thus we start the timer (Line 17). Given that, we are now sure that ${ Fi }^{(k)}$ and $Ti ^{(k)}$ are now computed correctly.

Therefore, we are now sure that $os^{(k)}$, $sp^{(k)}$, ${ Fi }^{(k)}$, and ${ Ti }^{(k)}$ are computed correctly. newRule() is thus sure to be fed the correct arguments, and will return the correct rule node. $\square$

Proof for Theorem 2

Here, we return a list of all possible synapse nodes $Syn ^{(k)}$. getCandidates() has not been specified in this paper and is assumed to return a list of all possible combinations of created/deleted synapses based on permutations of destination neurons and synapse counts of applicable plasticity rules. Given this, we are ensured that $Sy _+^{(k)}$ and $Sy _-^{(k)}$ are the appropriate synapse creation and deletion matrices of each synapse node to be created. Thus, $Sy _\Delta ^{(k)}$ would then hold the appropriate synapse change matrix for the same synapse node and would thus be appropriately passed onto the constructor for $Syn ^{(k)}$ and be included in the return list. Therefore, getSyns() returns the correctly computed synapse nodes appropriate for the given rule node. $\square$

Proof for Theorem 3

Given the definitions of $Fi _{\mathcal{S}}$, $Sr_{\mathcal{S}}$, and $Sy$, we have

$$\begin{aligned} G_{\mathcal{S}}^{(k)}&\overset{?}{=} Fi _{\mathcal{S}}^{(k)} \times Sr_{\mathcal{S}} \times Sy ^{(k)} \\&= \Big [fi_{{\mathcal{S}},i}^{(k)}\Big ]_{{r_{{\mathcal{R}}}}} \times \Big [sr_{{\mathcal{S}},i,j}\Big ]_{{r_{{\mathcal{R}}}}\times m} \times \Big [sy_{i,j}^{(k)}\Big ]_{m \times m} = \Big [\sum _i{fi_{{\mathcal{S}},i}^{(k)} sr_{{\mathcal{S}},i,j}}\Big ]_m \times \Big [sy_{i,j}^{(k)}\Big ]_{m \times m} \end{aligned}$$

Since $fi_{{\mathcal{S}},i}^{(k)} = 1$ if rule ${r_{{\mathcal{S}},i}}$ has spiked at time k (0 otherwise), and $sr_{{\mathcal{S}},i,j} = 1$ if ${r_{{\mathcal{S}},i}}$ belongs to neuron $\sigma _j$ (0 otherwise), we have

Thus, $\sum _i{fi_{{\mathcal{S}},i}^{(k)} sr_{{\mathcal{S}},i,j}}$ is the number of spiking rules that have spiked at time k from neuron $\sigma _j$. However, given that we have restricted neurons to only fire a maximum of one rule each, the value of this summation will only ever be 0 or 1, only indicating whether the neuron had a spiking rule fire or not. Continuing further, $sy_{i,j}^{(k)} = 1$ if neuron $\sigma _i$ is connected to $\sigma _j$ at time k (0 otherwise), so

$$\begin{aligned} G_{\mathcal{S}}^{(k)}&\overset{?}{=}\Big [\sum _i{fi_{{\mathcal{S}},i}^{(k)} sr_{{\mathcal{S}},i,j}}\Big ]_m \times \Big [sy_{i,j}^{(k)}\Big ]_{m \times m} \\&= \Big [ \sigma _{i} \overset{\Sigma s}{ \underset{(k)}{\rightarrow } } \sigma _{} \Big ]_m \times \Big [sy_{i,j}^{(k)}\Big ]_{m \times m} = \Big [ \sigma _{i} \overset{s}{ \underset{(k)}{\rightarrow } } \sigma _{} \Big ]_m \times \Big [ \sigma _{i} \overset{}{ \underset{(k)}{\rightarrow } } \sigma _{j} \Big ]_{m \times m} \\&= \Big [ \sum _i{\Big (\Big ( \sigma _{i} \overset{s}{ \underset{(k)}{\rightarrow } } \sigma _{} \Big )\Big ( \sigma _{i} \overset{}{ \underset{(k)}{\rightarrow } } \sigma _{j} \Big )\Big )} \Big ]_m = \Big [ \sum _i{ \sigma _{i} \overset{s}{ \underset{(k)}{\rightarrow } } \sigma _{j} } \Big ]_m = \Big [ \sigma _{} \overset{\Sigma s}{ \underset{(k)}{\rightarrow } } \sigma _{j} \Big ]_m \end{aligned}$$

Spiking rules can only cause spike gains in a destination neuron if some other source neuron fires a spiking rule to the said destination, and so we finally have

$$\begin{aligned} G_{\mathcal{S}}^{(k)} \overset{?}{=}\Big [ \sigma _{} \overset{\Sigma s}{ \underset{(k)}{\rightarrow } } \sigma _{j} \Big ]_m = \Big [ g_{{\mathcal{S}},j}^{(k)} \Big ]_m \overset{\checkmark }{=}G_{\mathcal{S}}^{(k)} \end{aligned}$$

$\square$

Proof for Theorem 4

Since plasticity rules can only cause spike gains by creating synapses (because creating synapses would inherently send one spike to the destination neuron), we only need to check $Sy _+^{(k)}$. Given the definition of $Sy _+$, we have

$$\begin{aligned} G_{\mathcal{P}}^{(k)}&\overset{?}{=}\sum _{i=1}^{{r_{{\mathcal{P}}}}}{ Sy _{+,i}^{(k)}} = \Big [\sum _{i}{sy_{+,i,j}^{(k)}}\Big ]_m = \Big [\sum _{i}{ \sigma _{i} \overset{+}{ \underset{(k)}{\rightarrow } } \sigma _{j} }\Big ]_m\\&\quad = \Big [ \sigma _{} \overset{\Sigma +}{ \underset{(k)}{\rightarrow } } \sigma _{i} \Big ]_m = \Big [g_{{\mathcal{P}},i}^{(k)}\Big ]_m \overset{\checkmark }{=}G_{\mathcal{P}}^{(k)} \end{aligned}$$

$\square$

Proof for Theorem 5

Both spiking and plasticity rules can only cause spike loss through spike consumption upon rule firing. Thus

Since $sr_{{\mathcal{R}},i,j}$ will only have a nonzero value if rule ${r_{{\mathcal{R}},i}}$ is in neuron $\sigma _j$, we have

Spike losses will only ever be caused by spike consumption from rule firing in a given neuron. Thus, also given the definition of

Lines 9–11 would tick the timer to get $Ti '^{(k)}$, by manually decreasing each element of the matrix by 1 unless the value is 0. $\square$

Proof for Theorem 6

By definition, $Conf ^{(k)} = (C^{(k)}, Sy ^{(k)}, Ti '^{(k)})$. Lines 1 to 8 have been proven to correctly compute for $C^{(k)}$ and $Sy ^{(k)}$. The loop in Line 9 iterates over all plasticity rules, while the inner loop of Line 10 goes over the two plasticity operations creation (1) and deletion (2). Line 11 would then either count down the current unprimed timer ($ti_{i,j}^{(k)} - 1$), or keep it at zero (max). Thus, the loops correctly compute for $Ti '^{(k)}$. Line 12 thus returns the correct configuration node via the constructor for $Conf ^{(k)}$, being passed the correct arguments for $C^{(k)}$, $Sy ^{(k)}$, and $Ti '^{(k)}$. $\square$

Proof for Theorem 7

The first three lines are just for initialization. The loop in Line 4 iterates over the configuration nodes in a breadth-first manner (seen by the use of dequeue and enqueue). Line 6 would cut off the computation graph once it reaches a given depth. The loop in Line 9 would go through the rule nodes, connecting them to configuration nodes first before heading to the loop in Line 13. This loop would go through the synapse nodes and connect them to the rule nodes, and then generates a new configuration node in Line 16. These two inner loops, from the rule nodes down to the immediate next configuration nodes, would generate these three levels in a depth-first manner (as seen with pop and push). Essentially, what happens is (1) given a configuration node, generate the subtree of these configuration nodes up to three levels in depth-first manner, (2) go through these configuration nodes in breadth-first manner. $\square$