{'fraction_non_alphanumeric': 0.04940649182394342, 'fraction_numerical': 0.016457158864105887, 'mean_word_length': 3.593116757799936, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 28, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Label Languages of 8-directional Array P System

An 8-directional array P system is one where the rewriting of an array can happen in any 8-directions. The array rules of such a system are labelled thus resulting in a labelled 8-directional array P system. The labelling is not unique and the label language is obtained by recording the strings over the labels used in any terminating derivation of the P system. The system is shown to generate interesting pictures. The label language is compared with Chomsky hierarchy.


Introduction
A P system is a new computing model abstracting the biological happening in membranes. Hence the system is also called membrane system. This computing model has several variants [5]. Most P system variants are computationally universal exhibiting the power of the systems. Recently, there were several research papers on array P systems. The arrays considered in [6] are set to evolve in a P system to generate various pictures. In [1] the authors set a collection of pictures made up of symbols to evolve using array rules mostly of isotonic type. The key idea was the construction of array language of halting P system. Hence it is interesting to look for the nature of P systems which have well defined halting configurations. Ginsburg and Spanier introduced controlled grammars, where the rules were applied in a restricted manner. The rules in any context-free grammar G were labelled uniquely by distinct symbols of a set C and the Context-free Grammar (CFG) G is regarded as a mechanism for translating strings over C into a language L(G, C) of strings. Every member of L(G, C) is generated by a sequential application of rules of G and the sequence being labelled by words over C. Associating a 'label' string with a halting computation of a P system is defined in [4]. The authors in this paper( [4]) realised the difficulty in associating labels with the rules in a parallel system and have overcome the difficulty by assigning the same label to more than rule. Hence they named the strings over the labels as control strings rather than label strings.
In [4] the authors looked at the control string associated with a computation of a P system with multi set of objects. The study of control languages of Tissue P-systems is initiated in [11]. In [9] the authors looked at the regulating evolution of an isotonic array P system where the evolution rules were either regular isotonic or context-free isotonic as defined in [8]. The authors in this paper( [9]) also introduce a new type of isotonic rule called restricted monotonic type which is different from the array rules used in [1]. Some of the interesting P systems which use arrays as data structures can be seen in [2,3].
In [7] the authors defined new array systems called 8-directional array grammar and 8-directional array P-System. The interpretation and manipulation of the data structure 'string' will be like 'turtle-like' graphs with possibilities to turn in multiples of 45 degrees. This array P system naturally can be seen to produce several interesting arrays of both rectangular and non rectangular in nature. Hence, the authors in [7] compare 8-directional array P System with the power of existing array models.
In this paper, we are interested in looking at the evolution of labelled array P system. In such a system , every array rule will be labelled. The labelling need not be unique. A label string is one in which the label symbols of the rules applied are concatenated in sequence and the associated derivation should be an halting one. Collection of such label strings form a label language.
In section 2, we give two definitions. They are 8-directional Array Grammar and 8-directional Array P System (8dAP S). In section 3, we define Labelled 8-directional Array P System (L8dAP S). A label string over the labels of the array P systems always meets a halting configuration. The set of such label string makes a label language. The set of arrays in the halting configuration may be some interesting pictures which other array systems could not generate. In section 4, we compare the label language with Chomsky hierarchy. We provide some comments and future direction research in section 5.
1. N is a finite non-empty set of symbols called non-terminals. 2. T is a finite non-empty set of symbols called terminals such that it is disjoint from N i.e. N ∩ T = ∅. 3. P is a finite non-empty set of θ-rotation rules of the form where A ∈ N , α, β ∈ (N ∪ T ) + , α contains exactly one non-terminal symbol and all other symbols in α are terminals, θ ∈ 0, π 4 , π 2 , 3π 4 , π, 5π 4 , 3π 2 , 7π 4 . While applying the former type of rule, A is rewritten by α in the direction of θ such that the leftmost symbol of α is placed in the position of A. For the later type of rule, α is replaced by β in the direction of θ such that the first symbol of β is placed in the position of the first symbol of α. 4. S ∈ N is the start symbol. Remark 1. For the rules of the form A → β θ , the symbols following A are to be shifted by |β − 1| positions in the direction of θ. For the rules of the form α θ → β θ the symbols following α are to be shifted by |β| − |α| positions in the direction of θ.
means, while applying the rule to any string of the form αXβ, the resultant array will be Y X α a β To the above array, if we apply the rule (aX) where V is the total alphabet, T ⊆ V is the terminal alphabet, µ is a membrane structure with m membranes labelled in a one-to-one manner with 1, 2, . . . , m; I 1 , . . . , I m are finite sets of initial arrays over V associated with the m regions of µ; R 1 , . . . , R m are finite sets of θ-rotation rules over V associated with the m regions of µ; ρ 1 , . . . , ρ m are partial order relations over R 1 , . . . , R m . The rules in R i are of the form A → α θ (tar), or α θ → β θ (tar), 2 ≤ |α| ≤ |β|, where tar indicates the target location of the output array obtained by applying such rules. The tar can be here, out or in. Here A ∈ (V \ T ), α contains exactly one non-terminal symbol and all other symbols in α are terminals, β ∈ V + and θ ∈ 0, π 4 , π 2 , 3π 4 , π, 5π 4 , 3π 2 , 7π 4 . There can be more than one rule with A or α on its left hand side. The array produced by using this rule will go to the membrane indicated by tar; i o is the output membrane.
We start from an initial configuration of the system and proceed iteratively, by transition steps performed by using the θ-rotation rules in parallel, to all arrays that can be rewritten, obeying the priority relations, and collecting the terminal arrays thus generated in a designated output membrane.
Note that each array is processed by one rule only, the parallelism refers here to processing simultaneously all available arrays by all applicable θ-rotation rules. If several rules can be applied to an array, may be in several places, then we identify only one possible location to apply a possible rule. It is important to have in mind the fact that the evolution of the arrays is not independent of each other, but interrelated in two ways : (1) if we have priorities, a rule r 1 applicable to an array A can forbid the use of another rule, r 2 , for rewriting another array, B, which is present at that time in the same membrane. In the next step if r 1 is not applicable to B or to the array A ′ obtained from A by using r 1 , then it is possible that the rule r 2 can now be applied to B; (2) even without priorities, if an array A can be rewritten for ever, in the same membrane or on an itinerary through several membranes, and if this cannot be avoided, then all arrays are lost, because the computation never stops. The arrays collected in the output membrane are then lost.
A computation is successful only if it halts, a configuration is reached where no rule can be applied to the existing arrays. The result of a halting computation consists of the arrays composed only of symbols from T (terminal symbols) placed in the membrane with label i o .

Labelled 8dAP S
In this section we introduce labelled 8dAP S. We illustrate the model with a few interesting examples which halt always on digitized pictures. An exactly labelled 8dAP S is an 8-directional array P system where every rule is labelled either with a symbol or 'λ'. The assignment of labels to rules need not be unique. The array rules are applied in a parallel distributed manner. The arrays are derived by any computation of a P system and such derivations of the system are labelled by strings over the labels. As the system being exactly labelled, the system is defined with a set of output arrays to which a derivation is built. The labels of the rules applied are concatenated in sequence with the application of the rules. Such a collection of strings will be called as label language.
where V, T, µ, I 1 , . . . , I m , R 1 , . . . , R m , ρ 1 , . . . , ρ m , i o are same as in Definition 2, lab is a finite set of alphabet, which is used for labelling the rules. Let R = m i=1 R i . Here we assign a label to every rule in R where the labels are chosen from the finite alphabet lab or the labels can be λ (empty label). Define a function f : R → lab ∪ {λ} called a labelling function that assign a label to each rule in R.
Noting that more than one rule may have the same label, but the same rule in different membranes cannot be assigned different labels. We extend the labelling for a label sequence S = r 1 r 2 . . . r k ∈ R * as follows : ′ between two successive configurations uses only rules with the same label b and rules labelled with λ. If at least one rule has a label b ∈ lab then the transition is called λ-restricted transition. If we allow all rules with λ label then the transition is called λ-unrestricted transition (or λ-transition).
A label string of input symbols (over lab) is said to be generated if all its symbols are consumed while Π transits from an initial configuration to a halting configuration. The output arrays in such a halting configuration are shown in F . The set of all label strings generated in this way by computations in a L8dAP S Π is denoted by L λ 8dAP (Π). The subscript indicates the fact that λ-steps (all rules applied in one step can have λ label) are permitted. When only steps where at least one rule with a non-empty label is used, the generating language is denoted by L8dAP (Π). The family of languages L8dAP (Π) associated with L8dAP S with at most m membranes is denoted by L8dAP m . In the unrestricted case, the corresponding language family is denoted by L λ 8dAP m . If the number of membranes is unbounded, then the subscript m is replaced with ⋆.
We now illustrate the system with some interesting examples. In example 2 the labelling language is regular where as in example 3 the label language is context-free. From these examples one can observe that the halting configuration set can contain both rectangular and non rectangular arrays.
Example 2. Consider the array language L star consisting of the star shaped arrays over x with each of the star having eight arms of equal length, (i.e.,) The LIAP S Π 1 with three membranes is given as, where The set of θ-rotation rules are given by L8dAP S Π 1 generating an exact label language L8dAP (Π 1 ) = a 16n n ≥ 1 , while it halts on an array that belongs to the set of picture configurations in F . The working of L8dAP S Π 1 with three membrane is as follows: The initial array in membrane one contains the array Applying rules 1, 2, 3, 4, 5, 6, 7 in membrane 1 and applying one of the lower priority rules say rule 8,the resulting array moves to region 2. In region 2, the variables A 1 , B 1 , C 1 , D 1 , E 1 , F 1 , G 1 are renamed as A, B, C, D, E, F , G by applying the rules 10, 11, 12, 13, 14, 15, 16 and finally the lower priority rule 17 is applied to rename the variable H 1 by H. The resultant array is sent back to membrane 1. The process can be repeated to generate the array of eight arms of equal length over {x} in membrane 3. To halt the computation rule 9 is applied instead of rule 8 in membrane 1 and the resultant array is sent to membrane 3. In membrane 3, rules 18 to 24 are applied.
Example 3. In this example, L8dAP S Π 2 halts on a swastik pattern L s of each arm length ≥ 3 in membrane 5, and it generates the exact label language which is context-free in nature. The L8dAP S with 5 membranes is given as, The set of θ-rotation rules are given by The label language generated by Π 2 is L8dAP (Π 2 ) = a 8n+4 b 8n+20 n ≥ 0 . The working of L8AP S Π 2 with five membranes is as follows: Starting with an initial array To generate a swastik pattern of each arm length n + 3, we first apply rules 1, 2, 3 and 4 in membrane 1 to Z. The resulting array moves to membrane 2. Rules 6, 7, 8 and 9 are applicable now and the array moves to membrane 1. The process can be repeated n times and the resulting array is as follows: Now, apply rules 1,2, 3 and 5 once in membrane 1 and expel the array to membrane 3, the label string so far will be a 8n+4 . Upper arm of a resulting array consists of a 0 followed by (n + 1) X's followed by A 1 . Other arms consists of n+ 1 copies Y 's, Z's and U 's in place of X's followed B 1 , C 1 and E 1 respectively. To replace each (n + 1) X's by 0's, apply rule 10 in region 3 and rule 14 in region 4 alternatively for n + 1 times. After replacing all X's, apply rule 10 in region 3 and rule 15 in region 4 once. The corresponding label string will be a 8n+4 b 2(n+1)+2 . Similarly, using rules 11, 12 and 13 in region 3 and rules 16, 17, 18, 19, 20 and 21 in region 4 all Y 's, Z's and U 's in the array can be replaced by 0's. The array is expelled to membrane 5. The corresponding label string is a 8n+4 b 8(n+1)+8 . In membrane 5, apply the only possible rules 22, 23, 24 and 25 once and halt the computation. The resulting label string becomes a 8n+4 b 8(n+1)+8+4 = a 8n+4 b 8n+20 . The swastik pattern of each arm length (n+3) is obtained in the output membrane 5.

Main Results
In the labelled array P system that we defined in section 3, the label language is a language over the labels such that for every string in the label language, there corresponds a halting computation of the P system that halts in one of the predefined final configurations. We also mentioned that the label can be λ. We now compare the label languages thus obtained with Chomsky hierarchy.
Notation: For any family P of languages, P \ {λ} means the family of λ-free languages.
Proof. Let G = (N, T, P, S) be a λ-free regular grammar and let it generate the language L. We assume that each production in P is of the form A → aB, A = B or A → a, where A, B ∈ N , a ∈ T . Suppose the production is of the form A → aA, to eliminate recursion, we replace A → aA with the set of new productions A → aA ′ and A ′ → aA by introducing a new non-terminal A ′ and also add productions A ′ → cB for each production A → cB ∈ P . So, we now obtain a new grammar G ′ = (N ′ , T, P ′ , S) from G. It is obvious that both the grammars G and G ′ generate the same language (i.e.,) L(G) = L(G ′ ). Let m be the number of non-terminals in G ′ . Now, rename the non-terminals in G ′ as A i , 1 ≤ i ≤ m, such that A 1 = S and also modify the productions with this renamed non-terminals. Now, we construct a L8dAP S Π 4 with one membrane such that L(G ′ ) = L8dAP S(Π 4 ) as follows: The L8dAP S Π 4 constructed above works as follows: Initially, the system contains a single symbol A 1 , the start symbol of G ′ . When the system chooses the Hence we can deduce the following: We conclude from Proposition 1 and Theorem ?? that (REG\{λ}) ⊂ L8dAP ⋆ . We proceed further to see whether (CF \ {λ}) ⊆ L8dAP ⋆ which we prove in the following theorem. Proof. Let L be a context-free language. Then let G = (N, T, P, S) be a contextfree grammar in Greibach normal form generating L. Let n be the number of non-terminals in N . Now rename the non-terminals in N as A i , 1 ≤ i ≤ n, such that A 1 = S and also modify the rules with this renamed non-terminals. Let G 1 = (N ′ , T, P ′ , A 1 ) be the grammar thus modified. We construct a L8dAP S Π 6 with one membrane such that L(G 1 ) = L8dAP S(Π 6 ) as follows: The arrays generated by L8dAP S Π 6 are in F = (⋆ ⋆ · · · ⋆ ⋆) : number of Initially, the L8dAP S Π 6 starts with an axiom A 1 . Now, apply either a rule a : A 1 → (⋆y) 0 which corresponds to A 1 → ay or the rule a : A 1 → (⋆) 0 that corresponds to A 1 → a. If we apply the latter rule, then the system halts on one of the final configurations in F . The corresponding label string generated by Π 6 is a. Suppose, we choose the former rule, A 1 is replaced with ⋆y in the 0 degree direction, y is a string of non-terminals. We adopt the same procedure to the leftmost non-terminal in the array. Once we choose the rule a : A i → (⋆) 0 , then the leftmost non-terminal in the array is replaced by ⋆. The leftmost symbol in the array is not a non-terminal, so the non-terminal next to ⋆ is preferred. Again for this non-terminal we have two possibilities, either we can apply the rule a : A i → (⋆y) 0 or the rule a : A i → (⋆) 0 . Proceeding in this way, and applying the only possible rule A i → (⋆) 0 to rewrite remaining non-terminals in the array as ⋆'s, the system halts on the final configuration ⋆ ⋆ · · · ⋆ ⋆ : . Note that what ever w may be, the halting array is of the form n ⋆ ⋆ · · · ⋆ ⋆ with |w| = n. The label string is obtained by consuming a label of the rule in each step.
Remark 4. The context-sensitive language {a n b n c n : n ≥ 1} can be generated by a L8dAP S which gives the following proposition.
For the proof of this theorem we give a context-sensitive language which can not be a label language of any L8dAP S ⋆ . Consider the context-sensitive language L = {a 2 n n ≥ 0}. Since L is over one letter alphabet , all the rules in the L8dAP S must be an a-rule and we cannot use λ-label to any rule. Let (α) θ → β θ k be a θ-rotation rule such that α contains exactly one non-terminal (with zero or more number of terminals) and β k contains exactly k non-terminals (with zero or more number of terminals). Suppose on the contrary, let, L8dAP S Π 7 be a system with m membranes that generates L and halts on one of the final configurations. We show the non-existence of such a system only for m = 1. The argument for m membrane P system will be identical to this. The reason is that in both situations we need infinite number of rules in the membrane system to build L. Let A 1 , A 2 , . . . , A n be the arrays in the initial configuration of Π 7 . We recall that the successful halting computation means that the system must halt as well as the arrays remaining in the output membrane are terminal arrays (composed of only terminals).
In the following argument we actually look for rules in the membrane to build L recursively.
1. In order to generate a label string a, whose length is one, the system must go up to one step (transition). Therefore, each array A 1 , A 2 , . . . , A n in Π 8 must contain at most one non-terminal (no restriction on terminals). To reach the successful halting computation, we must apply one or more rules of type a : α θ → β θ 0 . Note that we have introduced at least one new rule to generate the control string a. 2. By (1) above we know that each array A 1 , A 2 , . . . , A n contains at most one non-terminal. To accept label string a 2 , the system must go up to two steps (transitions). In order to do this, at least to one of the array, we need to apply the rule of type a : α θ → β θ 1 , which is a new rule. This rule may be recursive or non-recursive . If the rule is recursive, then it also generates the label strings a 3 , a 5 , a 6 ,. . . / ∈ L. Suppose, it is non-recursive, we can apply it once, followed by an existing rule of type α θ → β θ 0 to halt the computation. Hence, to generate a 2 , we have introduced a new rule of type α θ → β θ 1 . 3. Similarly, in order to generate a 4 , the system must go up to 4 steps. At least for one of the arrays we need to apply the rules in a way that there is no recursion. In all the possible cases, if any of the rule is recursive, it leads to the generation of a label string not in L. Therefore, the only possibility is non-recursive rules. In all the cases, we can see at least one new rule is required to generate a 4 .
So, to generate each string in L = {a 2 n n ≥ 0}, we need to introduce at least one a-rule in each step. Since L is infinite, the number of a-rules required to generate L is also infinite. Now we give the argumentative proof similar to the above to show that there does not exist any L8dAP S to generate L. Suppose we assume that there is one such L8dAP S Π 7 with m membranes. If in any one of the m membrane contain a recursive a-rule ,then it leads to an infinite loop or the system generates a string not in L. On the other hand, if the system contains only non recursive a-rules then, the number of such a-rules must be infinite. Hence the theorem.
Proof. We show how L8dAP S will be recognized by a linear bounded automaton. In order to do this, we simulate a computation of a L8dAP S by remembering the number of symbols in the arrays and their corresponding shapes after the generating each symbol in the label string. We then show that the total number of symbols in the arrays is bounded by the length of the label string.
Consider a label language L of a L8dAP S Π 8 with m membranes and let p be the total number of rules in these m membranes. Let w = b 1 b 2 . . . b l , l ≥ 1 be a label string in L. Let A 1 , A 2 , . . . , A n be the arrays in the m membranes of Π 8 in the initial configuration. We build a multi-track non-deterministic LBA B which simulates Π 8 . In order for B to simulate Π 8 , it has to keep track the symbols in the arrays and their shapes after generating each symbol in the label string. So B has a track assigned to every rule of Π 8 , a track for each pixelsymbol triple (X, (x, y), i) ∈ V × Z 2 × {1, 2, . . . , n} and a track for each triple (X, A i , j) ∈ V × {A 1 , A 2 , . . . , A n } × {0, 1, 2, . . . }.
The array A i is plotted in the plane Z = i as follows: one of the symbols of the array A i is plotted at ((0, 0), i), the origin of the plane Z = i. Fix this symbol, and place the other symbols of the array as follows: a symbol left to it is plotted at ((−1, 0), i); a symbol right to it is plotted at ((1, 0), i); a symbol above to it is plotted at ((0, 1), i); a symbol below to it is plotted at ((0, −1), i); a symbol 45 degree angle to it, is plotted at ((1, 1), i); a symbol 135 degree angle to it, is plotted at ((−1, 1), i); a symbol 225 degree angle to it, is plotted at ((−1, −1), i); a symbol 315 degree angle to it, is plotted at ((1, −1), i). In general, if the fixed symbol is in the position ((x, y), i), then a symbol to its left, is plotted at ((x − 1, y), i); a symbol right to it, is plotted at ((x + 1, y), i); a symbol above to it, is plotted at ((x, y + 1), i); a symbol below to it, is plotted at ((x, y − 1), i); a symbol 45 degree angle to it, is plotted at ((x + 1, y + 1), i); a symbol 135 degree angle to it, is plotted at ((x − 1, y + 1), i); a symbol 225 degree angle to it, is plotted at ((x − 1, y − 1), i); a symbol 315 degree angle to it, is plotted at ((x + 1, y − 1), i). If any symbol of the array remains, then change the fixed position of the symbol and repeat the same procedure till all the symbols in the array are plotted.
B keeps track of the configuration of Π 8 by writing a positive integer 1 on each track assigned to the symbol-pixel triple (X, (x, y), i), the symbol X being plotted in the pixel (x, y) of the plane Z = i. And also writes a positive integer on each track assigned to the symbol-configuration triple (X, A i , j), denoting the number of symbols X in the array A i at the configuration j. Then for each triple (X, (x, y), i), B examines the chosen rule set and plots the symbols X in the pixel (x, y) of the plane Z = i by the procedure mentioned above, increasing the number on the track (X, A i , j) .
We can see that in any step of the computation, the tracks contain integers bounded by the number of symbols in a label string of Π 8 . The shapes of the arrays are also preserved.
The number of symbols in the arrays in any configuration C during a computation step is bounded by S(i), where i is the number of label symbols generated. Then the space used by B to record the configurations and to calculate the configuration change of Π 8 is bounded by t × log b (S(i)), where b denotes the base of the track alphabet and t denotes the number of tracks used. Finally, B checks the applicability of some more rules. If not, and also if it reaches one of the final configurations, it generates the label string w, otherwise it rejects. So the number of symbols in the arrays present in the system is bounded by the input length and hence the label language is a context-sensitive language.
For the proof of the inclusion RE ⊆ L λ 8dAP ⋆ , it is enough to prove that RE ⊆ L λ 8dAP 1 , since L λ 8dAP 1 ⊆ L λ 8dAP ⋆ .
For any L, there exists a Turing machine M = (K, {0, 1}, Γ, δ, q 0 , F ′ ) which halts after processing the input i 0 placed in its input tape if and only if i 0 = e(w) for some w ∈ L. So it is sufficient to show the simulation of the encoding e(w), and the transitions of the Turing machine with a L8dAP S on w.
• The transition δ(q, a) = (p, b, R) is simulated by the θ-rotation rule (q a c) 0 → (b p c) 0 , where c is some non-blank symbol.
• The transition δ(q, a) = (p, b, L) is simulated by the θ-rotation rule (c q a) 0 → (p c b) 0 , where c is some non-blank symbol.
1. For 1 ≤ i ≤ k, and the symbol a i ∈ H, the rule (q 0 0 1) 0 → (0 q i 1) 0 , labelled with a i is used, which introduces the symbol q i and it is the symbol used in the first transition for generating the encoding in Step 2. 2. Perform the computation e(au) = e(a)e(u), u ∈ H + , a ∈ H. Assume that the encoding of w is represented by encoding of each symbol of u padded by 0 on both ends. The simulation of au is performed by the following subprogram.
δ(q 1 , 1) = (q 0 , 1, R) The transitions of the sub-program can be simulated by the θ-rotation rules as shown in the beginning of the proof, and these rules are assigned with label λ. 3. Repeat the Steps 1 and 2 non-deterministically until the last symbol of the label string w is consumed. 4. The output array that remains in the system is e(w)x : w ∈ L , which belongs to the set of final configuration. The array reduced in the system is equal to e(w)x for some w ∈ H + . We now start to simulate the working of the Turing machine M for recognizing the string e(w). If the Turing machine halts, by introducing the following transitions: δ(q 0 , 0) = (0, x, R) and if the corresponding θ-rotation rule is labelled with λ, then w ∈ L. Otherwise the machine goes into an infinite loop.
So, we can see that the computation halts after generating a string w if and only if w ∈ L.

Concluding Remarks
In this paper we introduced a new array P system called labelled 8-directional array P system (8dAP S). The data structure 'string' is interpreted as 'turtle-like' graphs with a possibilities to turn in multiples of 45 degrees. This P system-based fractal description model can be used to construct several interesting pictures. In the labelled 8dAP S the rules are labelled and the evolution of the system yields a label language. The label language thus obtained is compared with Chomsky hierarchy. We can understand the halting nature of this P system by means of its 'dependability'. By dependability we mean to study the halting nature or halting configurations of P system via string over the labels of the rules. We know that in our model every rule is labelled and strings over the set of labels lead the application of the rules. Such strings decide the strategy of movements in the parallel distributed computing model, P system. Hence the study becomes significant. The main difference between grammar rewriting system of describing some space filling curves like 'Koch curve' and our recursive 8-directional array P system is that, we do not re-scale the template. If we are able to record the shrinking effect, then our 8dAP S can generate almost all curves like 'Koch curve', Peano curve etc. One can also extend the study to understand more about space filling curves which have important role in antenna designing. One of the other future work can also looking at control languages of other variants of P-systems [5] such as Tissue P-systems with arrays as data structures.