A Bio-Inspired Model of Picture Array Generating P System with Restricted Insertion Rules

Abstract

In the bio-inspired area of membrane computing, a novel computing model with a generic name of P system was introduced around the year 2000. Among its several variants, string or array language generating P systems involving rewriting rules have been considered. A new picture array model of array generating P system with a restricted type of picture insertion rules and picture array objects in its regions, is introduced here. The generative power of such a system is investigated by comparing with the generative power of certain related picture array grammar models introduced and studied in two-dimensional picture language theory. It is shown that this new model of array P system can generate picture array languages which cannot be generated by many other array grammar models. The theoretical model developed is for handling the application problem of generation of patterns encoded as picture arrays over a finite set of symbols. As an application, certain floor-design patterns are generated using such an array P system.

1. Introduction

In the area of membrane computing [1,2,3], the novel computing model of P systems, introduced by Păun [4], has served as a framework for dealing with problems in different areas of applications [5], such as optimization problems [6,7,8,9], robots [10,11,12], power systems fault diagnosis [13,14,15], modelling complex market interactions [16], image process [17] and clustering [18], and for Turing computing power [19,20,21,22] and computing efficiency [23,24,25,26,27,28], both in its basic form and in its several variants. One such area of application of P systems is formal language theory with different models of P systems having been developed [29,30,31,32] for handling the problem of generation of classes of languages, starting with the seminal work of Păun [4]. In the extension of language theory to two dimensions, P systems have also played a significant role with different kinds of P systems with array objects and array evolving rules having been introduced (see, for example, [33,34,35]).

The operation of insertion on words [36,37,38,39] has been studied in string language theory in the context of DNA computing [40]. Fujioka [41] considered this operation in two-dimensional picture arrays and introduced a picture array generating model. This model has a feature which is analogous to the pure 2D context-free grammar [42] where the operation is rewriting in parallel all symbols in a column or a row of a (rectangular) picture array by strings of equal length while in [41], insertion (instead of rewriting ) of strings of equal length is done in parallel between columns or between rows.

Here we consider a restricted type of insertion rules with the “contexts” of length at most one, in the regions of a cell-like P system with the objects in the regions being rectangular picture arrays. The main objective of this study is to develop a new theoretical model of an array P system based on the bio-inspired computing model in the area of membrane computing, endowed with the capability to handle the problem of generation of two-dimensional patterns encoded as picture arrays. We compare the generative power of the resulting array P system model introduced here with other well-investigated picture array generating models. We also exhibit an application to generation of floor-design patterns, called “kolam” patterns [43]. A preliminary version of this paper was presented in the conference ACMC 2018 [44].

In Section 2, needed notions and notations relevant to the study undertaken are briefly described, with Section 2.1 providing the basic notions and Section 2.2 recalling picture-insertion system in a restricted form. In Section 3, the new model of array P system with restricted picture insertion rules $\left(APRPIS\right)$ is introduced. In Section 4, $APRPIS$ with one and two membranes are compared. In Section 5, comparison with Pure 2D context-free grammars is done while in Section 6, comparison with certain standard array generating models is carried out. Section 7 provides an application of the new model to generation of floor-designs. In the final Section 8, concluding remarks are given.

2. Preliminaries

For notions related to formal language theory, the reader can refer to [45] and to [42,46,47] for two-dimensional array grammars and languages. For P systems and array P systems, we refer to [4,34].

2.1. Basic Notions

A finite set V of symbols is called an alphabet. A word or a string $\alpha =a_1{a}_2\dots a_m,$$a_i\in V,1\le i\le m,$$(m\ge 1)$ of length m over an alphabet V is a finite sequence of symbols belonging to $V.$ The length of a word $\alpha$ is denoted by $\left|\alpha \right|.$ The set of all words over V, including the empty word $\lambda$ with no symbols, is denoted by $V^{*}$. For any word $w=a_1{a}_2\dots a_n$, ${}^{t}w$ is the vertical word with the word w written vertically. For example, if $\alpha =bab$ over the alphabet $\{a,b\},$ then ${}^t\alpha$ is $\begin{array}{c}b\\ a\\ b\end{array}.$ If w is a single symbol of the alphabet, then we write ${}^{t}w$ as w itself. A rectangular $p\times q$ array (also called picture array) X over an alphabet V is of the form

$$X=\begin{array}{ccc}{a}_{11}& \cdots & a_{1q}\\ ⋮& \ddots & ⋮\\ a_{p1}& \cdots & a_{pq}\end{array}$$

where each $a_{ij}\in V,1\le i\le p,1\le j\le q$. The number of rows of X and the number of columns of X are respectively denoted by ${\left|X\right|}_r$ and ${\left|X\right|}_c.$ The set of all rectangular arrays over V is denoted by $V^{**}$, which includes the empty array $\lambda$. $V^{++}=V^{**}-\left\{\lambda \right\}$. A picture language is a subset of $V^{**}.$

The column catenation $X\circ Y$ of two arrays X and Y with the same number of rows is formed by juxtaposing Y to the right of $X.$ The row catenation $X\diamond Y$ of two arrays X and Y with the same number of columns is formed by juxtaposing Y below $X.$ For example, if

$$X=\begin{array}{ccccc}a& b& a& a& b\\ b& b& b& a& a\\ a& a& b& a& b\\ a& a& b& b& b\end{array},Y=\begin{array}{ccc}b& b& a\\ b& b& b\\ a& a& b\\ a& b& b\end{array},Z=\begin{array}{ccccc}b& b& a& b& b\\ b& a& b& a& b\\ a& a& a& b& b\end{array},$$

then

$$X\circ Y=\begin{array}{cccccccc}a& b& a& a& b& b& b& a\\ b& b& b& a& a& b& b& b\\ a& a& b& a& b& a& a& b\\ a& a& b& b& b& a& b& b\end{array},X\diamond Z=\begin{array}{ccccc}a& b& a& a& b\\ b& b& b& a& a\\ a& a& b& a& b\\ a& a& b& b& b\\ b& b& a& b& b\\ b& a& b& a& b\\ a& a& a& b& b\end{array}.$$

2.2. Picture-Insertion System

A picture-insertion system has been considered in [41] with insertion in a picture array being done between columns or between rows, extending the notion of insertion in words [40]. We recall the definition of this system [41] with a special case, namely, with “contexts" of length one in the rules and call this system as a restricted picture-insertion system.

Definition 1.

A restricted picture-insertion system $\left(RPIS\right)$ is a 4-tuple ${\Gamma }=({\Sigma },I_c,I_r,A)$ where

(i) 

Σ is an alphabet;

(ii) 

$I_c=\{c_i\mid 1\le i\le m\},$$(m\ge 1)$ where $c_i,$ called a column insertion table, is a finite set of column insertion rules with alphabetic contexts of the form $(a,\alpha ,b),$$a,b\in {\Sigma }\cup \left\{\lambda \right\},\alpha \in {{\Sigma }}^{*}$ such that for any two rules $(a_1,\alpha ,b_1),(a_2,\beta ,b_2)$ in $c_i$, we have $\left|\alpha \right|=\left|\beta \right|$ and either both the left contexts $a_1$ and $a_2$ are in Σ (likewise the right contexts $b_1$ and $b_2$ are in Σ) or both are λ;

(iii) 

$I_r=\{r_j\mid 1\le j\le n\},$$(n\ge 1)$ where $r_j,$ called a row insertion table, is a finite set of row insertion rules with alphabetic contexts of the form $(d,{}^t\gamma ,e),$$d,e\in {\Sigma }\cup \left\{\lambda \right\},\gamma \in {{\Sigma }}^{*}$ such that for any two rules $(d_1,{}^t\gamma ,e_1),(d_2,{}^t\delta ,e_2)$ in $r_j$, we have $\left|\gamma \right|=\left|\delta \right|$ and either both the up contexts $d_1$ and $d_2$ are in Σ (likewise the down contexts $e_1$ and $e_2$ are in Σ) or both are λ;

(iv) 

$A\subseteq {{\Sigma }}^{**}-\left\{\lambda \right\}$ is a finite set of axiom arrays.

For picture arrays $P,Q\in {{\Sigma }}^{**},$ a one-step derivation in the $RPIS$${\Gamma },$ denoted by $P\Rightarrow Q,$ yields Q from P whenever either $\left(i\right)$ or $\left(ii\right)$ holds: $\left(i\right)$ if ${}^t{a}_1\cdots a_m$ and ${}^t{b}_1\cdots b_m$ are two adjacent columns, namely, columns j and $j+1$ for some $j,1\le j\le n-1,$ in the picture array P of size $m\times n,$ and if $(a_i,{\alpha }_i,b_i),1\le i\le m$ are column insertion rules in a column insertion table in $I_c,$ then the rules can be applied in parallel by inserting ${\alpha }_i$ in the ith row between $a_i$ and $b_i$ for all $i,1\le i\le m$ or $\left(ii\right)$ if $d_1\cdots d_n$ and $e_1\cdots e_n$ are two adjacent rows, namely, rows k and $k+1$ for some $k,1\le k\le m-1,$ in the picture array P of size $m\times n,$ and if $(d_i,{}^t{\beta }_i,e_i),1\le i\le n$ are row insertion rules in a row insertion table in $I_r,$ then the rules can be applied in parallel by inserting ${}^t{\beta }_i$ in the ith column between $e_i$ and $d_i$ for $1\le i\le n.$ Likewise insertions to the immediate left or right (respy. immediate up or down) of a column (respy. row) in the picture array P can be defined by requiring the corresponding left or right or up or down contexts in the rules used, to be $\lambda .$

The picture language $L\left({\Gamma }\right)$ generated by ${\Gamma }$ consists of picture arrays derived in one or more finite number of derivation steps starting with an axiom array in $A.$ The family of picture languages generated by $RPIS$ is denoted by $RPIL.$

Example 1.

Consider the $RPIS$${{\Gamma }}_1=({\Sigma },I_c,I_r,A\})$ where ${\Sigma }=\{a,b\}$, $I_c=\left\{c_1\right\},I_r=\left\{r_1\right\},$ where

$$c_1=\left\{(a,ab,b)\right\},r_1=\{(a,a,\lambda ),(b,b,\lambda )\}$$

and A consists of the array $\begin{array}{cc}a& b\\ a& b\end{array}.$

${{\Gamma }}_1$ generates a picture language $L_1$ consisting of picture arrays $X\circ Y$ with X over a and Y over b and ${\left|X\right|}_r={\left|Y\right|}_r{,\left|X\right|}_c={\left|Y\right|}_c.$ A member of $L_1$ is shown in Figure 1.

Starting with the axiom array in $A,$ in any step of a derivation, the application of the column insertion rule of $c_1$ inserts $ab$ in every row between a and b while the application of the row insertion rule of $r_1$ inserts in every column and just below a row, the symbol a below a and the symbol b below $b.$ In other words, for example, a derivation in which rules of $c_1$ and then rules of $r_1$ are applied, is shown below:

$$\begin{array}{cccc}a& a& b& b\\ a& a& b& b\\ a& a& b& b\end{array}{\Rightarrow }^{c_1}\begin{array}{cccccc}a& a& a& b& b& b\\ a& a& a& b& b& b\\ a& a& a& b& b& b\end{array}{\Rightarrow }^{r_1}\begin{array}{cccccc}a& a& a& b& b& b\\ a& a& a& b& b& b\\ a& a& a& b& b& b\\ a& a& a& b& b& b\end{array}.$$

3. Array P System with Restricted Picture Insertion Rules

Linking the two areas, namely, membrane computing and picture languages, an array P system with array-rewriting rules, was introduced in [33], which is one of the earliest models in this topic. This model motivated extensive research with several variants of array P systems being introduced based on different considerations (See, for example, [35] and references therein). We now introduce a new kind of array P system with picture arrays as objects and with restricted picture insertion rules in the regions.

Definition 2.

An array P System with restricted picture insertion rules $\left(APRPIS\right)$ is ${\Pi }=({\Sigma },\mu ,F_1,\cdots ,F_m,R_1,\cdots ,R_m,i_o),$ where: Σ is the alphabet, μ is a membrane structure with m membranes labelled in a one-to-one way with $1,2,\cdots ,m$; $F_i,1\le i\le m,$ is a finite set (can be empty) of axiom picture arrays over Σ in the ith region of μ; $R_i,1\le i\le m$ is a finite set of column or row insertion tables as in a $RPIS$ in the ith region of μ; each of the tables has an attached target here, out, in. (as usual, here is omitted and is understood). $i_o$ is the label of an elementary membrane of μ (the output membrane).

A computation in $APRPIS$ is defined in the same way as in an array-rewriting P system [34,35] with the successful computations being the halting ones: each array, from each region of Π, which can be obtained by applying the restricted picture insertion rules to the arrays associated with that region, should be obtained but rules of only one table is applied; the array obtained in a region is placed in the region indicated by the target associated with the table of rules used; the target here indicates that the array remains in the same region, out indicates that the array is sent to the immediate outer region except for the outermost skin membrane in which case the array sent out is “lost” in the environment; and in indicates that the array is sent to the immediately inner membrane, nondeterministically chosen (but if no innner membrane exists, then the table of rules with the target indication in cannot be used). A computation is successful only if it stops and a configuration is reached where no table of rules can be applied to the existing arrays. The result of a halting computation consists of the arrays placed in the output membrane with label $i_o$ in the halting configuration. The set of all such arrays computed or generated by the system Π is denoted by $AL\left({\Pi }\right)$. The family of all array languages $AL\left({\Pi }\right)$ generated by systems Π as above, with at most m membranes, is denoted by $A{P}_m\left(RPIS\right).$

We illustrate with an example.

Example 2.

Consider the $APRPIS$ ${{\Pi }}_1=({\Sigma },{{[}_1{{[}_2]}_2]}_1,F_1,F_2,R_1,R_2,2)$ where ${\Sigma }=\{a,b,e\}$, $F_1=\left\{\begin{array}{cc}a& b\\ a& b\end{array}\right\}$, $F_2=\varphi .$$R_1$ consists of the column insertion tables $(c_1,in),(c_2,in)$ and $R_2$ consists of row insertion table $(r,out)$ where

$$c_1=\left\{(a,ab,b)\right\},c_2=\left\{(a,e,b)\right\},r=\{(a,a,\lambda ),(b,b,\lambda )\}.$$

In a computation in ${{\Pi }}_1,$ since only the region 1 has an axiom picture array $\begin{array}{cc}a& b\\ a& b\end{array}$, application of the rule of the table $c_1$ will insert $ab$ between a and b in every row and the resulting array is sent to region 2 due to target indication $in.$ Application of the rules in r in region 2 inserts a row below one of the rows with a below a and b below b and the array is sent back to region 1 due to target indication $out.$ The process can repeat. If in region 1, the rule of the table $c_2$ is applied then e is inserted between a and b in every row resulting in an array of the form

$$\begin{array}{ccccccc}a& \cdots & a& e& b& \cdots & b\\ ⋮& \ddots & ⋮& ⋮& ⋮& \ddots & ⋮\\ a& \cdots & a& e& b& \cdots & b\end{array}$$

and the array is sent to the output region 2. The computation halts as no other rule could be applied. Note that in the rules in r there is no rule that allows insertion below e and hence the rules of the table r can no longer be applied. The arrays generated are of the form $M_1\circ M_2\circ M_3$ where $M_1$ is an array over $a,$$M_3$ is an array over b and $M_2$ is an array with only one column of $e^{\prime }s.$ Also, $|M_1{|}_c=|M_3{|}_c={|M_1\circ M_2\circ M_3|}_r.$ In otherwords, the number of rows of the array generated equals the number of columns of $M_1$ which equals the number of columns of $M_3.$ One such array is shown in Figure 2.

4. A Hierarchy between One Membrane and Two Membranes

We now compare the families $A{P}_1\left(RPIS\right)$ and $A{P}_2\left(RPIS\right)$ and establish that $A{P}_1\left(RPIS\right)$ is properly included in $A{P}_2\left(RPIS\right).$ It remains to explore whether the hierarchy collapses or not for higher number of membranes.

Theorem 1.

$$RPIL=A{P}_1\left(RPIS\right)\subset A{P}_2\left(RPIS\right)$$

Proof. 

In a $RPIS$ as well as $APRPIS$ with one membrane, the rules are only the $RPIS$ rules and so it is clear that $RPIL=A{P}_1\left(RPIS\right).$ Also by definition, the inclusion $A{P}_1\left(RPIS\right)\subseteq A{P}_2\left(RPIS\right)$ follows. The proper inclusion follows from Example 2 on noting that in any picture array M generated, the number of columns = $2\times$ the number of rows $+1.$ If there is only one membrane, there is no way to control application of the rules of the column and row tables as all the tables of rules are in the same region. ☐

5. Comparison with Pure 2D Context-Free Grammars

We now compare the generative power of $APRPIS$ with certain similar picture generating models. The insertion rules considered both in $RPIS$ and $APRPIS$ are restricted forms of the insertion rules considered in the picture insertion system defining the class $INPA$ [41]. Yet we show that there are picture array languages generated by $APRPIS$ with two membranes that are not in the class $INPA.$ Also, in [42], a picture array generating model, called pure 2D context-free grammar $\left(P2DCFG\right),$ is proposed and the generative power of this model is investigated. In this model, all symbols in a column or in a row of a $m\times n$ picture array are rewritten by pure context-free rules [42] of the form $a\to \alpha$ with $\alpha$ in all the rules in a table having the same length. The family of languages generated by $P2DCFG$ is denoted by $P2DCFL.$ Two variants of $P2DCFG,$ called $(l/u)P2DCFG$ and $(r/d)P2DCFG$ which are incomparable with $P2DCFG$ have also been considered [48,49]. In a $(l/u)P2DCFG$ the symbols in the leftmost column or the uppermost row only are rewritten while in a $(r/d)P2DCFG$ the symbols in the rightmost column or the lowermost row are rewritten. We show that there are picture array languages that can be generated by $APRPIS$ with two membranes but cannot be in $P2DCFL,$ $(l/u)P2DCFL$ and $(r/d)P2DCFL.$

Theorem 2.

1.

$A{P}_2\left(RPIS\right)-P2DCFL\ne \varphi$

2.

$A{P}_2\left(RPIS\right)-(l/u)P2DCFL\ne \varphi$

3.

$A{P}_2\left(RPIS\right)-(r/d)P2DCFL\ne \varphi$

4.

$A{P}_2\left(RPIS\right)-INPA\ne \varphi$

Proof.

Consider the picture array language $L_2$ consisting of $m\times (3n+2)$ arrays $(m\ge 2,n\ge 1),$ such that an array in $L_2$ is of the form $M_1\circ M_2\circ M_3\circ M_4\circ M_5$ where $M_1,M_3,M_5$ are $m\times n$ arrays over $\left\{a\right\},\left\{b\right\},\left\{d\right\}$ respectively and $M_2,M_4$ are $m\times 1$ arrays over $\left\{e\right\}.$ The language $L_2$ cannot belong to any of the families $P2DCFL,$$(l/u)P2DCFL$ and $(r/d)P2DCFL$ because in $P2DCFG$ generating in different modes, a language in any of these families, symbols in an array can be rewritten in only one column at a time. The language $L_2$ cannot also belong to the class $INPA$ for a similar reason. This means that the array with columns of $a^{\prime }s$ in the beginning, columns of $b^{\prime }s$ in the middle and columns of $d^{\prime }s$ in the end, equal in number, cannot be generated.

The language $L_2$ is generated by the $APRPIS$${{\Pi }}_2$ with two membranes where

$${{\Pi }}_2=(\{a,b,d,e\},{{[}_1{{[}_2]}_2]}_1,F_1,F_2,R_1,R_2,2)$$

with $F_1=\{\begin{array}{ccc}a& b& d\\ a& b& d\end{array},\}$$F_2=\varphi .$$R_1$ consists of the column insertion table. $(c_1,in)$ and a row insertion table $(r,here)$ and $R_2$ consists of the column insertion tables $(c_3,out),(c_2,here),(c_4,here)$ where

$$c_1=\left\{(a,ab,b)\right\},c_2=\left\{(a,e,b)\right\},$$

$$c_3=\left\{(b,d,d)\right\},c_4=\left\{(b,be,d)\right\},$$

and

$$r=\left\{\right(a,a,\lambda ),(b,b,\lambda ),(d,d,\lambda \left)\right\}.$$

The region 1 alone has an axiom picture array. So a computation in ${{\Pi }}_2$ can start in this region with the applicable tables of rules. If the rule of column insertion table $c_1$ is applied then $ab$ will be inserted in every row between two adjacent columns of $a^{\prime }s$ and $b^{\prime }s$ and the array is sent to region 2. If in this region the rule of column insertion table $c_3$ is applied then d will be inserted in every row between two adjacent columns of $b^{\prime }s$ and $d^{\prime }s$ and the array is sent back to region 1. The process can repeat. At any time, the rule of the row insertion table r can be applied, thus inserting in the picture array a row of the form $a\cdots ab\cdots bd\cdots d.$ If at any time, instead of $c_3$, the rule of the column insertion table $c_2$ (respy. $c_4$) is applied in region 2, then a column of $e^{\prime }s$ will be inserted between two adjacent columns of $a^{\prime }s$ and $b^{\prime }s$ (respy. columns of $b^{\prime }s$ and $d^{\prime }s$ ). A correct sequence of application of the rules is to apply now in region 2, the rule of the column table $c_2$ followed by $c_4$ or $c_4$ followed by $c_2,$ thus generating a picture array of the form shown in Figure 3. Region 2 is the output region and arrays collected here form the picture array language generated which is $L_2.$

6. Comparison with Certain Standard 2D Grammar Models

A well-known class of two-dimensional picture array languages, called the family of context-sensitive matrix languages $\left(CSML\right)$, was introduced by Siromoney et al. [50]. The corresponding class of grammars, known as $CSMG$ involves two phases of generation with the first phase generating a string s over intermediate symbols and in the second phase all the intermediate symbols in s are rewritten in parallel by regular nonterminal rules of the form $A\to aB,$ or together terminated by regular terminal rules of the form $A\to a,$ ($A,B$ are nonterminals and a is a terminal symbol), thus generating the columns of the picture array. The words in the first phase form a context-sensitive language. An extension, called $TCSML$ of the family $CSML$ was introduced in [51] by having in a $CSMG,$ an additional feature of tables of nonterminal rules or tables of terminal rules in the second phase. It was shown in [51] that $CSML\subset TCSML.$ We show here that there are picture array languages that cannot be in $TCSML$ but can be generated by $APRPIS$ with two membranes.

Theorem 3.

$A{P}_2\left(RPIS\right)-TCSML\ne \varphi$

Proof.

Consider the picture array language $L_3$ consisting of $(2m+1)\times (2m+1)$ arrays, $(m\ge 1),$ such that an array in $L_3$ is of the form $(M_1\circ M_2\circ M_3)\diamond M_4\diamond (M_3\circ M_2\circ M_1)$ where $M_1,M_3$ are $m\times m$ arrays over $\left\{a\right\},\left\{b\right\}$ respectively, $M_2$ is an $m\times 1$ array over $\left\{e\right\}$ and $M_4$ is an $1\times (2m+1)$ array over $\left\{e\right\}.$ A member of $L_3$ is shown in Figure 4. The language $L_3$ cannot belong to the family $TCSML.$ In fact in a grammar generating a picture array in a language in $TCSML,$ the number of rows above and below a distinct row of a generated array, cannot be maintained to be equal as the application of the tables of rules cannot be controlled.

The language $L_3$ is generated by the $APRPIS$${{\Pi }}_3$ with two membranes where

$${{\Pi }}_3=(\{a,b,e\},{{[}_1{{[}_2]}_2]}_1,F_1,F_2,R_1,R_2,2)$$

with $F_1=\left\{\begin{array}{cc}a& b\\ b& a\end{array}\right\},$$F_2=\varphi .$$R_1$ consists of the column insertion tables $(c_1,in),(c_2,in)$ and $R_2$ consists of the row insertion tables $(r_3,out),(r_4,here)$ where

$$c_1=\{(a,ab,b),(b,ba,a)\},c_2=\{(a,e,b),(b,e,a)\},$$

$$r_3=\{(a,{}^{t}ab,b),(b,{}^{t}ba,a)\},r_4=\{(a,e,b),(b,e,a),(e,e,e)\}.$$

Starting with the axiom picture array in region 1, a computation in ${{\Pi }}_3$ can start in this region with the applicable tables of rules. If the rules of column insertion table $c_1$ are applied then $ab$ will be inserted in every row between the two symbols a and b in two adjacent columns while $ba$ will be inserted in every row between the two symbols b and a in the same two adjacent columns, thus adding two columns to the picture array. The array generated is sent to region 2. If in this region the rules of row insertion table $r_3$ is applied then ${}^{}ab$ will be inserted in all columns between the symbols a and b in two adjacent rows while ${}^{}ba$ will be inserted between the symbols b and a in the same two adjacent rows, thus adding two rows to the picture array and the array is sent back to region 1. The process can repeat. If at any time, the rules of the column insertion table $c_2$ are applied in region 1, then a column of $e^{\prime }s$ will be inserted between the two adjacent columns ${}^{t}a\cdots ab\cdots b$ and ${}^{t}b\cdots ba\cdots a$ and the array is sent to region 2. A correct sequence of application of the tables of rules is to apply now in region 2, the rules of the row table $r_4,$ thus generating a picture array of the form shown in Figure 4. Region 2 is the output region and arrays collected here form the picture array language generated which is $L_3.$ ☐

Head [52] introduced splicing systems while proposing a theoretical model of DNA recombination. Berstel et al. [53] introduced a variant of splicing system, known as flat splicing system and noted ([53] P4) that the flat splicing system involving the operation of flat splicing on words and the insertion system [40] involving the operation of insertion on words, have similarity but the systems are incomparable. Extending the operation of flat splicing to picture arrays, a picture array generating model, called array flat splicing system $\left(AFS\right),$ was introduced and investigated in [54]. Here we show that picture array languages that cannot be generated by any $AFS$ can be generated by $APRPIS$ with two membranes. The family of picture array languages generated by $AFS$ is denoted by $L\left(AFS\right).$

Theorem 4.

$A{P}_2\left(RPIS\right)-L\left(AFS\right)\ne \varphi$

Proof.

Consider the picture array language $L_4$ consisting of $m\times (n+2)$ arrays, $(m\ge 2,n\ge 1),$ such that an array in $L_4$ is of the form $M_1\circ M_2\circ M_3$ where $M_1,M_3$ are $m\times 1$ arrays over $\left\{x\right\},\left\{y\right\}$ respectively and $M_2$ is an $m\times n$ array over $\left\{a\right\}.$ A member of $L_4$ is shown in Figure 5. The language $L_4$ does not belong to the family $L\left(AFS\right)$ [54].

The language $L_4$ is generated by the $APRPIS$${{\Pi }}_4$ with two membranes where

$${{\Pi }}_4=(\{x,y,a\},{{[}_1{{[}_2]}_2]}_1,F_1,F_2,R_1,R_2,2)$$

with $F_1=\left\{\begin{array}{ccc}x& a& y\\ x& a& y\end{array}\right\}.$$F_2=\varphi .$$R_1$ consists of the column insertion tables. $(c_1,here),(c_2,in)$ and a row insertion table $(r,here)$ where

$$c_1=\left\{(x,a,a)\right\},c_2=\left\{(a,a,y)\right\},r=\{(x,x,\lambda ),(y,y,\lambda ),(a,a,\lambda )\}.$$

We note that the rule of the column insertion table $c_1$ inserts a column of $a^{\prime }s$ but the array remains in the region 1 itself. The rule of the column insertion table $c_2$ has the same effect but the array is sent to the output region 2. The rule of the row insertion table r inserts a row of the form $xa\cdots ay$ while an array is generated. ☐

A class of array grammars called parallel contextual array grammars was considered in [55]. Several variants were introduced and their properties established. External parallel contextual array grammar is one such variant generating rectangular picture arrays and the family of picture array languages generated by this kind of array grammars is denoted by EPCA. Here we show that there are picture array languages not in EPCA, which can be generated by $\left(APRPIS\right).$

Theorem5.

$A{P}_2\left(RPIS\right)-\mathrm{EPCA}\ne \varphi$

Proof.

Consider the picture array language $L_5=L_5^{\prime }\cup L_5^{″}.$$L_5^{\prime }$ consists of $3\times (2n+1)$ arrays, $(n\ge 0),$ such that an array $M^{\prime }$ in $L_5^{\prime }$ is over $\left\{a\right\}$ and is of the form as shown in Figure 6. $L_5^{″}$ consists of $3\times (2n+3)$ arrays, $(n\ge 0),$ such that an array $M^{″}$ in $L_5^{″}$ is over $\{a,b\}$ and is of the form as shown in Figure 7. The first and last columns of $M^{″}$ are respectively $\begin{array}{c}a\\ b\\ a\end{array}$ and $\begin{array}{c}b\\ a\\ b\end{array}$ while all other symbols are a. The language $L_5$ has been proved to be not in the family EPCA ([55] Lemma 4.5).

But the language $L_5$ is generated by the $APRPIS$${{\Pi }}_5$ with two membranes where

$${{\Pi }}_5=(\{a,b\},{{[}_1{{[}_2]}_2]}_1,F_1,F_2,R_1,R_2,2)$$

with $F_1=F_2=\{M_1=\begin{array}{ccc}a& a& a\\ a& a& a\\ a& a& a\end{array},M_2=\begin{array}{ccc}a& a& b\\ b& a& a\\ a& a& b\end{array}\}.$$R_1$ consists of the column insertion tables. $(c_1,here),(c_2,in)$ where $c_1=\{(a,aa,a),(a,aa,b)\},c_2=\left\{(a,aa,\lambda )\right\}.$$R_2=\varnothing .$

Since region 2 is the output membrane, the axiom arrays in this region will be collected in the language generated. There are no rules in region 2. So in a computation in ${{\Pi }}_5$ only the rules in region 1 can be applied to the arrays in region 1. Initially, the rules of the table $c_1$ as well as the rule of the table $c_2$ are applicable and any of these should be applied to both the arrays $M_1$ and $M_2.$ If the rules of the table $c_1$ are applied to both $M_1$ and $M_2,$ then two columns of $a^{\prime }s$ are inserted yielding arrays

$$\begin{array}{ccccc}a& a& a& a& b\\ b& a& a& a& a\\ a& a& a& a& b\end{array},\begin{array}{ccccc}a& a& a& a& a\\ a& a& a& a& a\\ a& a& a& a& a\end{array}$$

but the arrays remain in the same region 1 as the column table $c_1$ has target $here$ associated with it. The process can repeat. If the rule of the table $c_2$ is applied to any of the arrays generated in an earlier step (including the axiom arrays), then again two columns of $a^{\prime }s$ are inserted into the array but the generated array is sent to output region 2. Since there are no rules in region 2, these arrays cannot evolve further and are collected in the language generated by ${{\Pi }}_5.$ The language generated is $L_5.$

7. An Application of the Model to “Kolam” Pattern Generation

A “kolam” pattern [43] is a visually pleasing floor design, more common in South India, drawn with curly lines around points arranged in a particular pattern, resulting in the intended “kolam” drawing. In [43] “kolam” patterns were considered as picture arrays in the two-dimensional plane with the labels of the cells of the picture array representing primitive “kolam” patterns [56]. In fact array grammars developed in [43] were used to generate the picture arrays and the labels were replaced by the corresponding primitive patterns, thus yielding the kolam pattern composed of these primitive patterns. Here we illustrate by constructing a $APRPIS$ generating picture arrays representing a particular set of “kolam patterns”, one member of which is shown in Figure 8. The labels of the arrays stand for the primitive kolam patterns defining the “kolam”. An array representing this kind of a kolam is shown in Figure 9.

Let $L_k$ be the picture language consisting of $(m+2)\times (2n+3),m\ge 1,n\ge 1$ picture arrays p such that $p(i,1)=p(i,n+2)=p(i,2n+3)=b,$ for $i\in \{1,m+2\},$$p(1,j)=d_1$ for $2\le j\le n+1;n+3\le j\le 2n+2,$$p(n+2,j)=d_2$ for $2\le j\le n+1;n+3\le j\le 2n+2,$$p(i,1)=d_3,$ for $2\le i\le n+1,$$p(i,2n+3)=d_4,$ for $2\le j\le n+1,$$p(i,n+2)=e,$ for $2\le i\le n+1$ and all other $p(i,j)=d.$ Here $d_1,d_2,d_3,d_4,d,e$ stand for the “kolam" primitive patterns as in Figure 10 and b stands for blank.

The picture language $L_k$ is generated by the $APRPIS$ with alphabet. $\{d_1,d_2,d_3,d_4,d,e,b\},$ membrane structure ${{[}_1{{[}_2{{[}_3]}_3]}_2]}_1,$ axiom array $\begin{array}{ccccc}b& d_1& b& d_1& b\\ d_3& d& e& d& d_4\\ b& d_2& b& d_2& b\end{array}$ in region 1 and no axiom array in regions 2 and 3, with 3 as the output region. The sets $R_1,R_2,R_3$ are the sets of tables of insertion rules in regions 1,2 and 3 respectively, where $R_1$ contains a column insertion table $(c_1,in)$ and a row insertion table $(r_1,here),$$R_2$ contains two column insertion tables $(c_2,out)$ and $(c_3,in).$ Here

$$c_1=\{(d_1,d_1,b),(d,d,e),(d_2,d_2,b)\},c_2=\{(b,d_1,d_1),(e,d,d),(b,d_2,d_2)$$

$$c_3=\{(d_1,d_1,b),(d,d,d_4),(d_2,d_2,b)\},$$

$$r_1=\{(b,d_3,d_3),(d_1,d,d),(b,e,e),(b,d_4,d_4)\}.$$

In a computation, the rules of table $c_1$ insert a column of the form ${}^t{d}_{1}d\cdots d{d}_2$ to the left of the middle column of $e^{\prime }s$ while the rules of table $c_2$ insert a similar column to the right of the middle column of $e^{\prime }s.$ The generated array is sent to region 2 from region 1 on applying $c_1$ while it is sent from region 2 to region 1 on applying $c_2.$ The process can repeat adding equal number of columns to the left and right of the middle column. The application of the rules of the table $r_1$ inserts below the first row, a row of symbols $d_{3}d\cdots ded\cdots d{d}_4$ as many times as needed and the generated array remains in region 1. When the rules of the table $c_3$ are applied in region 2, it has the same effect as applying $c_2$ but the insertion is to the left of the last column and the array is sent to the output region 3, with the computation halting. The generated arrays are the picture arrays of $L_k$ and no other array is generated. On replacing the labels of the squares in a generated picture array by the corresponding primitive kolam patterns shown in Figure 10, we obtain the “kolam” itself. One such generated “kolam” is shown in Figure 8. It is interesting to note that the “kolam” pattern in Figure 8 has a mathematically pleasing feature of symmetrical subpatterns on the left and right of the middle line made of the primitive pattern e shown in Figure 10.

8. Concluding Remarks

In the framework of membrane computing, a new picture array generating model, called array P System with restricted picture insertion rules $\left(APRIS\right)$ has been introduced. The generative power of this model is exhibited by comparing it with many standard families of picture languages. The main theoretical contribution is that the new model $APRIS$ can generate picture array languages which cannot be generated by the other picture array grammar models considered here. It will be of interest to compare with other families of picture languages not considered here such as the family of picture languages generated by internal parallel contextual array grammars [55]. As an application of this new theoretical model, certain floor-designs, called “kolam” patterns are generated, thereby showing that the model can handle the problem of generation of patterns encoded as picture arrays over a finite set of symbols.