Simulations between Three Types of Networks of Splicing Processors

Networks of splicing processors (NSP for short) embody a subcategory among the new computational models inspired by natural phenomena with theoretical potential to handle unsolvable problems efficiently. Current literature considers three variants in the context of networks managed by random-context filters. Despite the divergences on system complexity and control degree over the filters, the three variants were proved to hold the same computational power through the simulations of two computationally complete systems: Turing machines and 2-tag systems. However, the conversion between the three models by means of a Turing machine is unattainable because of the huge computational costs incurred. This research paper addresses this issue with the proposal of direct and efficient simulations between the aforementioned paradigms. The information about the nodes and edges (i.e., splicing rules, random-context filters, and connections between nodes) composing any network of splicing processors belonging to one of the three categories is used to design equivalent networks working under the other two models. We demonstrate that these new networks are able to replicate any computational step performed by the original network in a constant number of computational steps and, consequently, we prove that any outcome achieved by the original architecture can be accomplished by the constructed architectures without worsening the


Introduction
In recent years, the limitations encountered by our standard computational models have become more apparent, motivating the pursuit of knowledge regarding innovative paradigms capable of overcoming these barriers. Along this line of research, different computational models finding their inspiration on natural phenomena have been proposed in the scientific community. Further research showed their theoretical proficiency for solving intractable problems.
This definition may be extended as follows. Given a language L over V and a finite set of splicing rules R, we define Given an alphabet V, two disjoint subsets P, F of V, and a string z over V, we define the following predicates: ϕ (s) (z; P, F) ≡ P ⊆ al ph(z) ∧ F ∩ al ph(z) = ∅ ϕ (w) (z; P, F) ≡ al ph(z) ∩ P = ∅ ∧ F ∩ al ph(z) = ∅.
In these predicates, the set of permitting contexts P defines the symbols that are required to be present in the current string while the set of forbidding contexts F refers to those symbols that are banned. Both clauses require the nonexistence of symbols a ∈ F in the string z and differ on the flexibility of the conditions related to P. The first one demands for all the symbols in P to exist in z, while the latter statement is met as long as one or more of the symbols in P belong to z.
A splicing processor with random-context filters (SP) over an alphabet V is a 6-tuple (S, A, PI, FI, PO, FO), where: -S is a finite set of splicing rules over V. - A is a finite set of strings over V. Each string in A is called an auxiliary string. -PI (permitting symbols) and FI (forbidding symbols) are two subsets of V, which both define the input filter of the processor. -PO, FO ⊆ V are similar subsets of V that define the output filter of the processor. We say a splicing processor is uniform if the input and output filters are identical: PI = PO = P and FI = FO = F. The set of all splicing processors over the alphabet U is denoted by SP U , while USP U denotes the set of all uniform splicing processors over U.
A network of splicing processors (NSP) is a 9-tuple Γ = (V, U, , , G, N , β, In, Halt), where: • V ⊂ U are the input and network alphabet, respectively. The working alphabet U contains two special symbols, namely, , that do not belong to V. • G = (X G , E G ) is an undirected graph defined by the set X G of vertices and the set E G of edges. As the graph does not contain loops, we define an edge by a binary set of vertices. G is called the underlying graph of the network. It is worth mentioning that many papers were dealing with NSP with a complete underlying graph, see, e.g., the survey [9].
• N : X G −→ SP U is a function that associates with each vertex x ∈ X G the splicing processor N (x) = (S x , A x , PI x , FI x , PO x , FO x ). • β : X G −→ {(s), (w)} is a function that associates with each vertex the type of both its input and output filters. We now define two mappings on the set of all strings over U \ { , }: Informally, ρ x (z) (resp. τ x (z)) decides whether or not the string z can pass the input (resp. output) filter of x. If L is a language, we define ρ that is the set of strings of L that can pass the input filter of x.
In an analogous way, we define τ x (L). Note that though we use the same notation for ρ x (w) (τ x (w)) and ρ x (L) (τ x (L)), there is no confusion because the arguments are different. • In, Halt ∈ X G are the input and the halting node of Γ, respectively. Likewise, a network of splicing processors is considered to be uniform if it is composed by uniform splicing processors. A network of uniform splicing processors (NUSP) is a 9-tuple Γ = (V, U, , , G, N , β, In, Halt),where: • V, U, , , G, In, Halt follow the same specifications as the parameters in NSP.
} specifies the strength of the sets P and F associated to node filters.
A network of splicing processors with filtered connections (NSPFC) is a 9-tuple Γ = (V, U, , , G, N , β, In, Halt), where: • V, U, , , In, Halt follow the same specifications as the parameters in NSP. • G = (X G , E G ) is also an undirected graph such that each node x ∈ X G is seen as a splicing processor without filters, with the set of splicing rules S x and the set of axioms A x . • N : E G −→ 2 U × 2 U associates with each edge e ∈ E G a pair of sets P e , F e that define the filter on the edge e. • β : E G −→ {(s), (w)} defines the predicate variant assigned to the edge filters. The size of a NSP Γ belonging to any of the variants above is defined as the number of nodes in the graph, i.e., card(X G ). A configuration of Γ is a mapping C : X G −→ 2 U * , which assigns a set of strings C(x) to each node x ∈ Γ, that is the sets of strings that can be found in node x at a given moment. Although for each x ∈ X G , C(x) is actually a multiset of strings, each string appearing in an arbitrary number of copies, for the sake of simplicity, we work with the support of this multiset. For a string z ∈ V * , the initial configuration of Γ on the input string z is C A configuration can be altered through a splicing step or a communication step. In a splicing step, all the splicing rules belonging to the set S x applicable to the strings in the set combination of C(x) and A x are realized, causing the change of C to a new configuration C . Formally, a configuration C evolves to C by a splicing step, denoted as C =⇒ C , if and only if the following proposition is true for all x ∈ X G : The communication step is different in NSP (NUSP) and NSPFC. We first define how a communication step works in a NSP (the definition of a communication step in a NUSP is very similar, hence left to the reader). In every node x, all the following tasks are accomplished simultaneously: The strings that satisfy the output filter condition of x are sent out; (ii) Copies of the expelled strings from any node y connected to x enter x, provided that they satisfy the input filter condition of x.
We stress that those strings sent out of x that do not satisfy the input filter condition of any node are definitely lost. Formally, a configuration C follows a configuration C by a communication step in a NSP (we write We now describe how a communication step works in a NSPFC. For every pair of connected nodes x, y, all the strings that satisfy the filter condition associated with the edge {x, y} are moved from one node to the other. Formally, C C , if The computation of a NSP Γ on the input string w ∈ V * is defined as a sequence of alternating steps (splicing, communication) that produces the configurations C (w) 2i+2 , for all i ≥ 0. The computation of NUSP and NSPFC are defined in the same way.
A computation as above halts, if there exists k ≥ 1 such that the set of strings existing in the output node C(Halt) is non-empty. Then, we say that the string w is admitted by the splicing network in an accepting computation. The language defined/accepted by Γ is the set of all strings w over V such that the computation of Γ on w is an accepting one.
The time complexity of the halting computation C m of Γ on x ∈ V * is denoted by time Γ (x) and equals m. The time complexity of Γ is the partial function from IN to IN formalized as follows: Analogously, one defines Time NUSP ( f (n)) as well as Time NSPFC ( f (n)).

Direct Simulations between NSPs and NUSPs
Obviously, since each NUSP can be immediately transformed into a NSP, we have: The converse is also true, namely: Proof. Let Γ = (V, U, <, >, G, N , β, x 1 , x n ) be a NSP with the underlying graph G = (X G , E G ) and X G = {x 1 , x 2 , . . . , x n } for some n ≥ 1; x 1 ≡ In and x n ≡ Halt. Let further We now define the nodes of G by Tables 1-3, while the edges of G are both listed as well as graphically represented. and {x s 1 , , then the nodes defined in Table 2 belong to X G .
All the edges belong to E G . As we have mentioned above, we present also a graphical representation in where PO x i = {Z 1 , Z 2 , . . . , Z p }, p ≥ 1. They are presented in Table 3. The output node x s n is defined as follows: S (x s n ) = S(x n ), P (x s n ) = PI(x n ) and F (x s n ) = FI(x n ), with A (x s n ) = A(x n ), β (x s n ) = β(x n ). Finally, we add all the edges {x continue i , x s n } | x i , x n ∈ E G , to E G . We now analyze a computation of Γ on an input string < w >. In the input node x s 1 , > is replaced with the sequence ψ >. Then, < wψ > enters x 0 1 , where ψ > is replaced with the symbols > # 1 and the resulting string is sent to the node x 1 1 . Thus, the node x 1 1 contains the string z =< w > # 1 associated to the input string z =< w > placed in the node x 1 ∈ Γ. More generally, we may assume that a string Note that any string produced in x 1 1 can return to x 0 1 . However, these strings have the character # 1 switched with θ 1 , which is not accepted by the connected nodes x s 1 and x 1 1 . Consequently, the node x 0 1 can be disregarded for the rest of the computation. We now start the simulation of the first splicing step executed by Γ. Firstly, we analyze the procedure for the case of a splicing node x i ∈ Γ. In can be applied to z 1 z 2 in the node x i ∈ X G . Let y 1 y 2 # i be one string obtained after a splicing step from z 1 z 2 # i in x 1 i . Note that if the splicing rule cannot be applied, then z 1 z 2 # i may go out from x 1 i and enter the following nodes: • x check−in i , provided that z 1 z 2 satisfies the condition of the input filter of , provided that z 1 z 2 does not satisfy the condition of the output filter of x i ∈ X G , • x 2 i (dom(S x i )). All cases are to be analyzed. If z 1 z 2 # i leaves x 1 i and enters x check−in i , the symbol # i is replaced with θ i , which locks the string in that node. If z 1 z 2 # i leaves x 1 i and enters x return 1 i , then ping-pong processes between these two nodes as well as between x 1 i and x 2 i (dom(S x i )) start. We distinguish here the cases of weak and strong filters. If β(x i ) = (w), the string z 1 z 2 # i can also enter x return 2 i , starting an identical relationship to the one between x return 1 i and the nodes , provided that z 1 z 2 # i does not contain the character Z k , followed by the same ping-pong process between these nodes and . In this last case, the structure simulates the situation where a string remains in the node x i because it only contains a proper subset of the characters in PO(x i ). If Note that this situation simulates exactly the situation when z 1 z 2 is sent to x j after staying unchanged for one splicing step in x i . The case when z 1 z 2 θ i enters any of the nodes x return 1 i and x return 2 i is considered above.
The only case remaining to be analyzed is when z 1 z 2 # i is transformed into y 1 y 2 # i (either y 1 = z 1 or y 2 = z 2 ) after applying a splicing rule in x 1 i . Then, y 1 y 2 # i leaves x 1 i . We follow the route of this string through the network: where u and v are replaced by u and v, respectively. We analyze in detail the case for a string y 1 y 2 θ i with y 1 = z 1 . The application of the first splicing rule on a string y = β 1 u y 2 θ i yields two strings, namely y = β 1 u # and y = πuy 2 θ i . These two strings cannot exit the node, as they contain # and π, respectively. In the next splicing step, these two strings can only combine between themselves through the second splicing rule {[(π, ub); (t, u #)], yielding two new strings: y 2 = πu # and y 2 = β 1 uy 2 θ i . The first one cannot be used in the computation anymore, while the latter is the original string y 1 y 2 θ i with u replaced by u. The procedure for a string y 1 y 2 θ i with y 2 = z 2 is analogous through the application of the other two splicing rules.
After leaving We now analyze the computational steps required for simulating a computation in Γ. The input node x s 1 and x 0 1 require 1 splicing step (or 2 computational steps) each. In the worst case, a splicing step in one of the nodes {x i | 1 ≤ i ≤ n − 1} can be simulated in Γ in 7 splicing steps (or 14 computational steps) distributed in the following way: Note that the simulation only requires 12 computational steps if x j ≡ x s n since x s n is not simulated by a subnetwork and the computation halts once a string enters that node. By all the above considerations, we conclude that L(Γ) = L(Γ ) and Time Γ (n) ∈ O(Time Γ (n)). Table 1. Description of the initial nodes. Table 2. Description of the intermediate nodes. Figure 1. A graphical representation of the network. Table 3. Description of the returning nodes.

Direct Simulations between NSPs and NSPFCs
. . , x n } for some n ≥ 1; x 1 ≡ In and x n ≡ Halt. We construct the NSPFC Γ = (V , U , <, >, G , N , β , x I , x s n ); x I ≡ In and x s n ≡ Halt, where We now define the parameters of Γ . First, for each pair of nodes The specifications for the input node x I and the output node x s n are as follows: A(x s n ) = A(x n ∈ Γ). and the edge: we add a subnetwork ( Figure 2).to Γ according to the cases considered in the sequel. Case 1. If x i is a splicing node with β(x i ) = (w), the subnetwork is defined as follows: The edges between them are:  We now analyze a computation of Γ on the input string w =< z >. In the input node x I , the symbol ψ is attached at the end of the string. Next, it enters x s 1 and the simulation of a computation in Γ starts. We assume that wψ lies in x s 1 while the string w is found in x 1 , the input node of Γ. Inductively, we may assume that a string w is found in some x i , a node of Γ, as well as wψ in x s i from Γ . Let x i be a splicing node, where a rule [(a, b)); (u, v)] is applied to w producing α 1 avβ 2 and β 1 ubα 2 , if w = α 1 abα 2 or w otherwise. In Γ , the string wψ is processed as follows. First wψ becomes w$ i in x s i , then it can enter x 1 i only. Here, it may become w = α 1 av β 2 $ i or w = β 1 u bα 2 $ i , if w = α 1 abα 2 , or it is left unchanged.
Further, a string of the form w $ i produced in this node can go back to x s i , where $ i is changed to θ, sealing that string in the node. On the other hand, the strings can also enter x 2 i . In x 2 i , the symbols $ i and σ are replaced by θ, closing the route back to x 1 i . Note that the other produced strings #$ i , #σ and #θ remain locked in the node.
Finally, the strings enter x f i where each symbol c ∈ u or c ∈ v , if present, is rewritten into the associated symbol c, replacing u with u and v with v. Thoroughly, the string w = α 1 av β 2 θ is split into the strings w 1 = α 1 avπθ and w 2 = #v β 2 θ. Both strings cannot leave the node because of the characters π and #. In the next splicing step, the only rule that can be applied to these strings is {[(av, π); (#v , t)]. At the same time, this rule can only be applied to these two new strings. The rule yields w 1 = α 1 avβ 2 θ and w 2 = #v πθ. The former contains the string generated by the original node x i , w 1 = α 1 avβ 2 , completing the simulation of the splicing step. On the other hand, the latter cannot exit the node or be modified by any rule, so it remains locked for the rest of the computation. The logic is analogous for the other string generated by the splicing rule. Thus, in node x f i , we have obtained the strings α 1 avβ 2 θ and β 1 ubα 2 θ, if w = αabα 2 .
In conclusion, if w ∈ U * is a string in the nodes x i of Γ and wψ in x s i of Γ , then we can obtain w ∈ U * in one splicing step of Γ if and only if we can obtain the associated string w θ in the node x f i of Γ in 4 splicing steps (or 8 computational steps). At this point, we note that w can leave x i and enter x j in Γ if and only if the string can leave x f i and enter x s j via the nodes x 1 i,j and x 2 i,j . If it can leave x i , but cannot enter x j in Γ, then it is trapped in x 2 i,j in Γ . Furthermore, a string entering x j has the character ψ replaced with $ j , and consequently, it cannot return back to x 2 i,j . Finally, if the string cannot leave the node x i , then it is sent by x f i to x i rt 1 and x i rt 2 (in the case of weak filters) or to the nodes x i rt 1 and x i rt k 2 , for all Z k ∈ PO(x i ) (in the case of strong filters). In these nodes, the character θ is replaced with σ, and the resulting string is sent to x 1 i . If the string is not split in the following splicing step, it returns to the nodes x i rt 1 and x i rt 2 in the case of weak filters or to the nodes x i rt 1 and x i rt k 2 in the case of strong filters, starting a ping-pong process between them, which continues until the string yields new ones by means of another splicing step in x 1 i . In this last case, the new strings can only enter x 2 i because it contains characters a ∈ U and the process described above is repeated.
We now analyze the computational steps required for simulating a computation in Γ. The input node x I and the node x s 1 require 1 splicing step (or 2 computational steps) each. In the worst case, a splicing step in one of the nodes {x i | 1 ≤ i ≤ n − 1} can be simulated in Γ in 7 splicing steps (or 14 computational steps) distributed in the following way: Note that the simulation only requires 12 computational steps if x s j ≡ x s n since the computation halts when a string enters x s n . We conclude that L(Γ) = L(Γ ) and Time Γ (n) ∈ O(Time Γ (n)).
The converse of the previous proposition holds. Proof. Let Γ = (V, U, <, >, G, N , β, x 1 , x n ) be a NSPFC with G = (X G , E G ), X G having n nodes x 1 , x 2 , . . . , x n ; x 1 ≡ In and x n ≡ Halt. We construct the NSP Γ = (V , U , <, > , G , N , β , x I , x s n ); x I ≡ In and x s n ≡ Halt, where We now define the parameters of Γ . First, we add a main subnetwork composed by the input node x I , the nodes {x s The edges between them are: Next, for each node x i | 1 ≤ i ≤ n − 1 in Γ, we add a subnetwork to Γ according to the cases considered in the sequel. Case 1. Let E i be the number of nodes connected to the node x 2 i of the form x i,j , we add the corresponding nodes {x rt Note that E i is also equal to the number of edges between the node x i and the nodes x j | 1 ≤ i = j ≤ n, i = n in the network Γ. If the edges {x i , x j } ∈ Γ have β = (w), the subnetwork is defined as follows: The edges between them are: The parameters S, A and β of these new nodes remain the same, while the input and output filters are defined as follows: In both cases, if the k edge has P {x i ,x j } = ∅, then the nodes x rt 2 i,j (k) and x rt t the whole subnetwork given in Figure 3 is removed because a string is always able to leave the node x i ∈ Γ through the edge k. Let us assume the string w =< z > to be the input string in Γ. In the input node x I of Γ , the symbol X 1 is attached to the string and then sent to the node x s 1 . Thus, the node x 1 ∈ Γ contains the string w =< z > while w =< z > X 1 lies in the analogous node x s 1 ∈ Γ . In a more general setting, we assume that a string y = yX i , y ∈ U * , enters x s i ∈ Γ at a given step of the computation of Γ on w if and only if the string y enters x i ∈ Γ at a given step of the computation of Γ on w.
Let y be transformed into z 1 = α 1 avs.β 2 and z 2 = β 1 ubα 2 in node x i and z 1 and/or z 2 can pass the filter on the edge between x i and x j . In Γ , the string y = yX i is transformed into z 1 = α 1 av β 2 X i and z 2 = β 1 u bα 2 X i in the node x s i . If the string is of the form y = yψ, it is transformed into z 1 = α 1 av β 2 X i and z 2 = β 1 u bα 2 ψ. The strings enter x 1 i where the characters X i and ψ are replaced with X i . Thus, we get the same strings with either X i or ψ. Then, it continues into x 2 i , where the symbols in u and v , if present, are replaced with the original counterpart u and v. In detail, the string z 1 is split into the strings z 1 (1) = α 1 avπX i and z 1 (2) = #v β 2 X i . Both strings cannot leave the node because of the characters π and #. In the next splicing step, the rule {[(av, π); (#v , t)] is applied to the two strings, yielding z 1 (1) = α 1 avs.β 2 X i and z 2 (2) = #v πX i . The former constitutes the string z = z 1 X i where z 1 is the string yielded by x i ∈ Γ, completing the simulation of the application of a splicing rule of Γ. On the other hand, the latter cannot exit the node or be modified by any rule, so it remains locked for the rest of the computation. The logic is analogous for the other string generated by the splicing rule. The new string z = z 1 X i is sent to the nodes x i,j associated to the edges {x i , x j } in the original network. Since the input filters of these nodes are identical to the edge filters in Γ, the string z 1 X i can enter a node x i,j ∈ Γ if and only if the string z 1 can pass the filter between x i and x j in Γ. Note that the converse is also true. Subsequently, the symbol X i is replaced with X j and the new string is sent to x s j ∈ Γ where a similar procedure starts. Alternatively, if the string y is not split in x i ∈ Γ, the same event happens in x s i ∈ Γ . If the string is of the form y = yψ, it remains locked in that node until a splicing rule can be applied on it while a string of the form y = yX i still enters the node x 1 i because of the symbol X i and the same computational process described above starts.
On the other hand, a copy of the string zX i is also sent to the subnetwork illustrated in Figure 3, where the case of a string not passing the filters of any edge between the node x i and the connected nodes in the original network Γ is handled. We distinguish here between the cases of strong and weak filters. For each edge k with β = (w), 1 ≤ k ≤ E i , the node x rt 1 i,j (k) checks if the string cannot enter the corresponding node x i,j (k) because of containing forbidden symbols, while the node x rt 2 i,j (k) verifies if the string contains the characters required by the PI filter of the node x i,j (k). Thoroughly, the string exits x 2 i and enters the first pair of nodes x rt 1 i,j (1) and x rt 2 i,j (1) granted that the associated string z could not pass the filters of the first edge in the network Γ. In that node, X i is replaced with Y 2 ensuring that the new string could only enter the next pair of nodes x rt 1 i,j (2) and x rt 2 i,j (2) associated to the second edge. Subsequently, Y k | 2 ≤ k ≤ E i − 1 is replaced by the next character Y k+1 in the remaining pair of nodes x rt 1 i,j (k) and x rt 2 i,j (k), forcing the string to continue through them in sequence. If the string can enter one of the connected nodes through an edge in Γ, it will be lost at some point of this subnetwork as it will be refused by the input filters of the nodes corresponding to that edge. Otherwise, it will reach the last pair of nodes where the symbol Y E i will be changed to ψ, yielding a string of the form zψ which will be returned to x s i . Because of the character ψ, this string cannot leave the node x s i ensuring it remains there until it can be used in a new splicing step. Thus, the following computational step in Γ was simulated in Γ : z could not leave the node x i and it remained in that node for new splicing steps. In the case of an edge k with strong filters, the computation follows the same procedure described above with the difference that the node x rt 2 i,j (k) is replaced with p ≥ 1 nodes of the form i,j (k) refuses any string z containing the character Z t . Thus, the string can only continue through this network by means of a node We analyze now the case where a string zX i enters x i,n from a node x 2 i , for some 1 ≤ i ≤ n − 1. In that node, X i is replaced with X n and the resulting string enters x s n , ending the computation. Note that by the considerations above, a string enters x i,n if and only if a string from x i was able to pass the filter on the edge between x i and x n in Γ.
We now analyze the computational steps required for simulating a computation in Γ. The input node x I requires 1 splicing step (or 2 computational steps). In the worst case, a splicing step in one of the nodes {x i | 1 ≤ i ≤ n − 1} can be simulated in the associated subnetwork in 4 + E i splicing steps (or 8 + 2E i computational steps) distributed in the following way: 2 steps in x i,j if the string z yielded by the splicing step in the node x i ∈ Γ could pass any of the edge filters between x i and x j in Γ; 1 ≤ i = j ≤ n, i = n. • 2E i steps if z could not pass any of the edge filters in Γ.
Since E i is bounded by n − 1, where n is the number of nodes in Γ, a NSPFC can be simulated by NSP in O(n) time. As a result of this analysis, we conclude that L(Γ) = L(Γ ) and Time Γ (n) ∈ O(Time Γ (n)).

Direct Simulations between NUSPs and NSPFCs
Proof. This proposition can be proved through a NSPFC simulation of NUSP identical to the proposed simulation for NSP in the previous section, with the only difference being the replacement of the filters PI, PO with P and FI, FO with F in the specifications.
Therefore, the input node x I and the node x s 1 require 1 splicing step (or 2 computational steps) each. In the worst case, a splicing step in one of the nodes {x i | 1 ≤ i ≤ n − 1} can be simulated in Γ in 7 splicing steps (or 14 computational steps) distributed in the following way: Similarly, we conclude that L(Γ) = L(Γ ) and Time Γ (n) ∈ O(Time Γ (n)).
The converse of the previous proposition holds.
Proof. Let Γ = (V, U, <, >, G, R, N , α, x 1 , x n ) be a NSPFC with G = (X G , E G ), X G having n nodes x 1 , x 2 , . . . , x n ; x 1 ≡ In and x n ≡ Halt. We construct the NUSP Γ = (V, U , <, > .G , N , α 1 , x I , x s n ); x I ≡ In and x s n ≡ Halt, where We now define the parameters of Γ . First, we add a main subnetwork composed by the input node x I , the nodes The edges between them are: Next, for each node x i | 1 ≤ i ≤ n − 1 in Γ, we add a subnetwork to Γ according to the cases considered in the sequel. Case 1. Let E i be the number of nodes connected to the node x 2 i of the form x i,j , we add the corresponding nodes {x rt Note that E i is also equal to the number of edges between the node x i and the nodes x j | 1 ≤ i = j ≤ n, i = n in the network Γ. If the edges {x i , x j } ∈ Γ have β = (w), the subnetwork is defined as follows: The edges between them are: Time NSP ( f (n)) = Time NUSP ( f (n)) = Time NSPFC ( f (n)) for any function f : IN −→ IN.

Conclusions and Further Work
As being a theoretical piece of work, the methodology used in this paper is the standard one: identifying the problem, discussing the theoretical implications and possible practical applications, stating the results, proving the statements, and discussing different aspects of the results.
We demonstrate here an efficient method to simulate different variants of NSP with random-context filters with each other. We describe a methodology to translate any network belonging to one of the three variants into an equivalent on of the other two models. The definitions of the former regarding splicing rules, auxiliary strings, random-context filters and connections between nodes are used to determine the corresponding ones for the new network. Later on, they are assigned to the nodes and edges according to an established procedure. Although the constructed networks may appear to be more complex and to have a significantly bigger size than the original network, the time complexity remains unchanged. This statement is proven true by the capability of these new networks to simulate any computational step in the original architecture in a constant number of computational steps. This method is theoretically important and attractive, as it allows direct and time efficient conversions of one variant of NSP into another one, avoiding intermediate computational models. Efficient simulations between different bio-inspired computational models are essential in the theoretical and practical studies in this field. It is common for these paradigms to be used as problem solvers, and simulations between two models would allow the scientific community to translate a solution proposed for one of the models to the other, avoiding the time and effort required otherwise. Furthermore, research about this topic could also have important practical applications in architecture design, such as the hypothetical establishment of systems, composed of a mix of different bio-inspired architectures, in an effort towards improving the efficiency of a given task.
As one can see, the underlying graph of the simulating network might be different than that of the original network. An attractive line for further research, which may be considered not only for the variants considered here, would be to impose some conditions on the topology of the underlying graph (to be the same as the original one, to have a predefined form, etc.).
Last but not least, we have started a study of possible numerical simulations and implementations of some of these models. A few steps have already been made by considering some possible ways of assigning probabilities to some similar models, see, e.g., [25][26][27].

Conflicts of Interest:
The authors declare no conflict of interest.