The Generative Power of d-Dimensional #-Context-Free ... - CiteSeerX

The Generative Power of d-Dimensional #-Context-Free Array Grammars Henning Fernau,

1

1

Rudolf Freund,

2

and Markus Holzer

1

Wilhelm-Schickard-Institut fur Informatik, Universitat Tubingen, Sand 13, D-72076 Tubingen, Germany email: ffernau,[email protected] 2 Institut fur Computersprachen, Technische Universitat Wien, Resselgasse 3, A-1040 Wien, Austria email: [email protected]

Abstract

The main result proved in this paper shows that the natural embedding of any one-dimensional array language in the two-dimensional space can be generated by a two-dimensional #-context-free array grammar. This result can also be extended to the two-dimensional case, and we conjecture that a similar result is true for arbitrary dimensions. Our result shows that in the array case, context-freeness of a certain kind already yields universality. Furthermore, we exhibit the essence of undecidability lying in the proof of our main result, thereby extending some complexity results of Morita, Yamamoto, and Sugata [11] in passing.

Keywords: Array grammars, context-freeness and universality, (un)decidability, word problem

1 Introduction Chomsky-type grammars have been de ned not only in order to generate strings, but also to generate, e.g., graphs and pictures. In this paper, we will address one particular picture description formalism, the so-called array grammars, a formalism which neatly generalizes Chomsky's ideas to the multi-dimensional case. In array grammars, the left-hand side of each rule speci es a d-dimensional sub-array that can be replaced by the corresponding right-hand side which lls the same sub-space in order to avoid the so-called shearing eect (isotonicity, see [12]; regarding the history of array grammars, we refer to [8, 17], where in particular the Japanese literature is reviewed.). Especially, in contrast to  The rst author was supported by the Deutsche Forschungsgemeinschaft grant DFG La 618/3-2 KOMET.

1

the string case, one has to take care of blank positions as well, so that these positions also occur in the sub-array de nition. Classical decidability problems like membership or (non-)emptiness are much harder for array grammars compared to the string case, as it has been investigated by Morita, Yamamoto, and Sugata [11]. For example, they showed that the membership problem is NP-complete for regular and for certain context-free array languages. Here, one might ask what is the meaning of context-freeness in array grammars. Indeed, one may take the string case de nition which permits exactly one nonterminal to occur at the left-hand side of each rule. Transferring this de nition literally to the array case leads us to the most general case of so-called #-context-free grammars, which will be in the focus of our present study. The paper is organized as follows. In the next section, we introduce the necessary notions. Section 3 presents our main result showing that the natural embedding of any one-dimensional array language in the two-dimensional space can be generated by a two-dimensional #-context-free array grammar. Especially, this result implies the undecidability of the word problem for this form of context-free array languages. In Section 4, we try to explore the boundary of the undecidable for #-context-free array grammars and extend some NPcompleteness results from [11]. In the last section, we indicate related partially open questions.

2 De nitions In this section, we introduce the necessary de nitions and notations for arrays and array grammars. For more details the reader is referred to [1, 4, 5, 13, 15]. Let Z denote the set of integers, N the set of positive integers, i.e., N = f1; 2; : : :g, and let d 2 N . Further, let V be an alphabet. Then, # 2= V is called the background or blank symbol. Consider a partial function A : Z d ! V [ f#g with domain W and de ne shape(A) = f v 2 W j A(v) 6= # g. A d-dimensional array A over an alphabet V is a total function A : Z d ! V [ f#g of nite shape. We usually shall write A = f (v; A(v)) j v 2 shape(A) g. The set of all d-dimensional arrays over V shall be denoted by V d. The empty array in V d with empty shape shall be denoted by d. Moreover, we de ne V +d = V d n fdg. Any subset of V +d is called a -free d-dimensional array language. Let v 2 Z d; v = (v1 ; : : : ; vd ). The norm of the vector v is de ned by kvk = max fjvi j j 1  i  d g. The translation v : Z d ! Z d is de ned by v (w) = w + v for all w 2 Z d, and for any array A 2 V d we de ne v (A), the corresponding d-dimensional array translated by v, by (v (A)) (w) = A (w ? v) for all w 2 Z d. The vector (0; : : : ; 0) 2 Z d is denoted by d . 2

Usually, arrays are regarded as equivalence classes of arrays with respect to linear translations [1, 13, 15], i.e., only the relative positions of the symbols 6= # in the plane are taken into  account: The equivalence class [A] of an array A 2 V d is de ned by [A] = B 2 V d j B = v (A) for some v 2 Z d . The set of all equivalence classes of d-dimensional arrays over V with respect to linear   translations shall be denoted by V d . For an array language L  V +d , we write [L] instead of f [A] j A 2 L g. Let d1 ; d2 2 N with d1 < d2 . The natural embedding id1 ;d2 : Z d1 ! Z d2 is de ned by id1 ;d2 (v) = (v; d2 ?d1 ) for all v 2 Z d1 . To a d1 -dimensional array A 2 V +d1 with A = f (v; A (v)) j v 2 shape (A) g we assign the d2 -dimensional array id1 ;d2 (A) = f (id1;d2 (v) ; A (v)) j v 2 shape (A) g. A d-dimensional array production p over V is a triple (W; A1 ; A2 ), where W  Z d is a nite set and A1 and A2 are mappings from W to V [ f#g such that shape (A1 ) 6= ;. We say that the array C2 2 V d is directly derivable from the array C1 2 V d by the d-dimensional array production (W; A1 ; A2 ) if and only if there exists a vector v 2 Z d such that C1 (w) = C2 (w) for all w 2 Z d n v (W ) as well as C1 (w) = A1 (?v (w)) and C2 (w) = A2 (?v (w)) for all w 2 v (W ), i.e., the sub-array of C1 corresponding to A1 is replaced by A2 , thus yielding C2 ; we also write C1 `p C2 . As can already be seen from the de nitions of a d-dimensional array production, the conditions for an application to a d-dimensional array B and the result of an application to B, a d-dimensional array production (W; A1 ; A2 ) is a representative for the in nite set of equivalent d-dimensional array productions of the form (v (W ) ; v (A1 ) ; v (A2 )) with v 2 Z d . Hence, without loss of generality, we can assume d 2 W as well as A1 ( d ) 6= #. Moreover, we often will omit the set W , because it is uniquely reconstructible from the description of the two mappings A1 and A2 by Ai = f (v; Ai (v)) j v 2 W g, 1  i  2. Thus in the sequel we will represent the d-dimensional array production (W; A1 ; A2 ) also by writing A1 ! A2 , i.e., f (v; A1 (v)) j v 2 W g ! f (v; A2 (v)) j v 2 W g. A d-dimensional array grammar is a sextuple G = (d; N; T; #; P; f(v0 ; S )g) ; where N is the alphabet of non-terminal symbols, T is the alphabet of terminal symbols, N \ T = ;, # 2= N [ T ; P is a nite non-empty set of d-dimensional array productions over N [ T and f(v0 ; S )g is the start array (axiom), v0 is the start vector, and S is the start symbol. An array production p 2 P is said to be #-context-free, if there exists some w 2 W such that A1 (w) 2 N and A1 (w) = # for all v 2 W n fwg. G is called #-context-free if every production in P is #-context-free. We say that the array B2 2 V d is directly derivable from the array B1 2  d V in G, denoted B1 `G B2 , if and only if there exists a d-dimensional array production p = (W; A1 ; A2 ) in P such that B1 `p B2 : Let `G be the re exive transitive closure of `G. The (d-dimensional) array  language generated by the array grammar G, L (G), is de ned by L (G) = A 2 T d j f(v0 ; S )g `G A . Observe that there are especially a lot of variants of de nitions of context-free 3

rules in the array case. An interesting feature of d-dimensional array productions, especially also of #-context-free array productions, is the fact that they make use of some special context, namely the context of blank-symbols #. This #-sensing ability induces a relatively high generating power and is the main ingredient of the construction used in the proof of our main result given in the following section. In order to show the diculties with de ning a suitable model of contextfreeness in the case of d-dimensional array productions we introduce some further notions. A d-dimensional array production p = (W; A1 ; A2 ) in P is called 1. quasi-monotonic, if card (shape (A1 ))  card (shape (A2 )); 2. non-blank-sensing, if shape (A1 ) [ shape (A2 ) = W ; 3. non-erasing, if shape (A2 ) 6= ;; 4. monotonic, if shape (A1 )  shape (A2 ); 5. chain rule, if card (shape (A1 )) = card (shape (A2 )) = 1; 6. #-context-free, if card (shape (A1 )) = 1 (which is just another way to de ne this type of rules, compare the de nition given above). A d-dimensional array grammar G is called quasi-monotonic, non-blanksensing, non-erasing, monotonic or #-context-free, respectively, if every array production in P is quasi-monotonic, non-blank-sensing, non-erasing, monotonic or #-context-free, respectively. Every monotonic rule and every chain rule is quasi-monotonic. Every quasimonotonic rule is non-erasing. In the literature, monotonic non-blank-sensing #-context-free array productions are the most commonly used variant for contextfree array productions.

3 The main result We are now going to show that #-context-free two-dimensional array languages include all recursively enumerable one-dimensional array languages (with respect to the natural embedding of the one-dimensional space in the two-dimensional space), which reveals an astonishingly high generative power of this model of context-free two-dimensional array grammars. Theorem 1. For every recursively enumerable one-dimensional array language L, there exists a #-context-free two-dimensional array grammar generating i1;2 (L). Proof. The basic idea is to simulate, in a bottom-up manner, a derivation of a one-dimensional array grammar G1 generating L. In order to avoid too tedious   constructions in this paper, we only give the proof for the case of [L]  T 1 : 4

Without loss of generality, we can assume G1 = (1; N1; T; #; P1 ; f(0; S1)g) to be in Chomsky (or Kuroda) normal form, i.e., every production in P1 is of one of the following forms: 1. A ! B for A 2 N1 and B 2 T [ f#g or 2. f( 1 ; A) ; (v; D)g ! f( 1 ; B ) ; (v; C )g for v 2 Z 1 , kvk = 1, A; B; C 2 N1; D 2 N1 [ f#g, i.e., we can also write AD ! BC for v = (1) and DA ! CB for v = (?1). We now de ne a #-context-free two-dimensional array grammar G2 generating i1;2 (L). Set G2 = (2; N2 ; T; #; P2; f( 2 ; S2 )g) and let



N2 = S2 ; S3 ; DL ; DR ; L; Lf ; L0f ; R; R0 [ f Uj j 1  j  m g [ f X R; X L j X 2 N1 [ T [ f#g [ fZL; ZR g g; where m is the cardinality of N1 [ T [ f#g [ fZL; ZR g. We enumerate the elements of N1 [ T [ f#g [ fZL; ZR g in such a way that we can refer to them as Y1 ; : : : ; Ym . To each Yi , 1  i  m, we assign its unary codi cation which is represented as

f ((0; j ) ; Um?j ) j 1  j  m; m ? j + 1 6= i g +1

and abbreviated as Yei , further, we also call Yei a \pile". Moreover, in order to give a succinct representation of the rules in P2 we use the following abbreviations: (1) # stands for f ((0; j ) ; #) j 1  j  m g, (2) #i = f ((0; j ); #) j 1  j  m; m ? j + 1 6= i g,

(3) #~ i = f((0; ?i) ; #)g, and (4) Ybi stands for f((0; ?i); Ui )g, e.g., instead of

f((0; 0) ; Lf ) ; ((0; ?i) ; #)g ! f((0; 0) ; #) ; ((0; ?i) ; #)g we simply write L#~f ! # #~ i : i Next, we give the set P2 of rules, which are classi ed according to the following ve modes of operations: (1) Initial generating mode (I-mode), (2) Copy-mode (C-mode), (3) Simulation mode (S-mode), (4) Termination mode (T-mode), and (5) Erasing mode (E-mode). I-mode. We start the derivation with #i ZfL S2 # ! ZLR S3 ; where ZL = Yi , 5

and proceed, for Yj = a, a 2 T [ f#g, with the rules L # e a #j R for Yk = ZR . ! ZfR S3 # ! a S3 ; and #k a # S3 # ZRR DR So we generate an arbitrary one-dimensional terminal array in two copies (one \original" and one copy with superscript R ) as well as a third copy in its unary representation by the corresponding \piles" Yei . The whole workspace for the accepting derivation, guessed in a non-deterministic way, at the left-hand side is indicated by ZL and at the right-hand side by ZR . On the right end of the copy with the superscript R we have introduced the right delimiter DR , and above the unary codings the variable L starting the C-mode of derivation. C-mode. Nonterminal L goes to the left; L downwards checks which symbol is encoded by sensing for the corresponding blank position and upwards creates the unary encoding again, when going to the left leaving back the corresponding symbol with the superscript L : #i Yei # L ! L YiL ; for Yi 2 N1 [ T [ f#g [ fZR g. #~ i Ybi When L has reached the left border, we introduce the left delimiter DL and above the unary codings the variable R starting the S-mode: R # #i ! ZfL # L DL ZLL ; for Yi = ZL . #~ i ZcL S-mode. Variable R now goes to the right; R downwards checks which symbol is encoded by sensing for the corresponding blank position and upwards creates the unary encoding again, when going to the right leaving back the corresponding symbol with the superscript R : #i Yei R # ! YiR R ; Yi 2 N1 [ T [ f#g [ fZLg. #~ i Ybi At some position we simulate a one-dimensional accepting array production from P1 and change from R to R0 . There are two possibilities for a simulation step: 1. For A ! B 2 P1 , A 2 N1 , B 2 T [ f#g, and Yi = A, Yj = B we take #i Ae R # ! AR R 0 #~j Bb 6

2. For AD ! BC 2 P1 , B; C 2 N1 , A; D 2 N1 [ f#g, fA; Dg \ N1 6= ;, Yi(X ) = X for X 2 fA; B; C; Dg, we take #i(A) #i(D) Ae De R # # ! AR DR R0 ~#i(B) # ~ i(C ) Bb Cb In the same way as R, the variable R0 continues to the right, too. R0 downwards checks which symbol is encoded by sensing for the corresponding blank position and upwards creates the unary encoding again, when going to the right leaving back the corresponding symbol with the superscript R : #i

R0 #

#~ i

Yei ! YiR R0 ; for Yi 2 N1 [ T [ f#g. Ybi

When R0 has reached the right border, we have two possibilities:

L ZfR ! 0 R # ZRR DR ; for Yi = ZR , #~ i Ybi introduces the right delimiter DR , and above the unary codings the variable L # #i

now can go to the left again starting the simulation of another derivation step in G1 . Yet instead, we may also choose to start the T-mode phase of the derivation by using

Lf f Z R ! 0 R # ZRR DR ; for Yi = ZR . #~ i Ybi

# #i

T-mode. In this phase, we start the check for the nal con guration only containing one non-blank position occupied by S1 . To this end, variable Lf runs to the left by # Lf ! Lf YiL ; for Y 2 fZ ; #g. i R #~ i Ybi

When S1 is detected, we change from Lf to L0f and continue the run to the left by using the rules # Lf ! L0f S1L ; for Y = S , i 1 #~ i Ybi 7

and

# L0f L0f #L ; for Y = #. ! i Ybi #~ i Finally, when L0f reaches the left border the only rule applicable is

L0f ! # ; for Y = Z , i L Ybi #~ i This indicates that the check has been successful, i.e., the original terminal one-dimensional array whose acceptance was checked belongs to the given language L. What remains is to erase the symbols representing the derivation steps in G1 , which is done in the E-mode. E-mode. In the last phase of the simulation, the variables are erased until only the terminal word, which has been checked for membership, remains. More precisely, a symbol with superscript L (R ) can only vanish when the symbol to its left (right) has disappeared. The trick to avoid erasing of the symbols during the simulation can be compared with an archway which holds itself by the gravitation and the boss. If the boss is taken away, the archway collapses. In our case the boss was the \leading nonterminal" L0f , which hopefully has disappeared at the last step in the T-mode, and the gravitation directions are modelled by the superscripts L and R . This is controlled by the rules # XL ! # #

and

XR # ! # # ;

for X 2 N1 [ T [ f#g [ fZL; ZR g. With # # # # # # # # ! # # ! # and # DR # DL # the right delimiter DR can only vanish when the whole line above generated to the left has disappeared completely; this now allows also the line having been generated to the right (indicated by the superscript R ) to vanish. The same holds for the left delimiter DL if we interchange right and left. Now we take care of the unary encoding of the variables Yi by using the rules

Um?j+1 ! # ; for 1  j  m. #~j

#~j

The piles Yi can only be erased when the corresponding symbols YiL and YiR have been erased. According to the explanations given above the reader can easily verify that [L (G2 )] = [i1;2 (L (G1 ))], which completes the proof. 2 8

For L  T 1, we have to mark the start position, because in the nal check we have to look for S1 occurring exactly on the start position (not on an arbitrary position). Moreover, for generating the needed workspace for the terminal onedimensional array we want to analyze, we have to generate symbols to the left and to the right of the start position, which causes an additional initial construction. In the two-dimensional case, i.e., L  T 2, we can use similar ideas for simulating a derivation of a grammar generating L. The initial construction yielding a square representing the workspace for the two-dimensional array to be analyzed can be done as in [5], where two-dimensional array grammars with #-context-free array productions and several control mechanisms were shown to characterize the family of two-dimensional recursively enumerable array languages; observe that for our purpose, where we have to remember the start position, the construction for squares given in [16] is not sucient. Theorem 2. For every recursively enumerable two-dimensional array language L there exists a #-context-free three-dimensional array grammar generating i2;3 (L). We even conjecture that for every recursively enumerable d-dimensional array language L there exists a #-context-free (d + 1)-dimensional generating array grammar generating id;d+1 (L). Unfortunately, a formal proof seems to need even more involved proof techniques; the crucial problem is not the simulation but the generation of the initial hypercube workspace. The proof of our main theorem immediately yields the following quite surprising result: Corollary 3. For every recursively enumerable one-dimensional array language L  T 1, there exists a two-dimensional array grammar G = (2; N; T 0; #; P; f(v0 ; S )g), T  T 0 , with every array production in P being of the form

f((0; 0); A); (v; #)g ! f((0; 0); a); (v; B )g or A ! a; where v 2 Z ; A; B 2 N; and a 2 T 0, such that i ; (L) = h(L(G)), where h : T 0 [ f#g ! T [ f#g is a projection with h(a) = a for a 2 T and h(X ) = # for X 2 T 0 n T . 2

12

4 Decidability and complexity issues In this section, we want to explore the boundary of the undecidable, i.e., we ask ourselves what is the essence of our undecidability proof? Looking back at the proof of our main result, we see that we only needed non-blank-sensing monotonic #-context-free rules and blank-sensing erasing rules. What can we say about other combinations of (non-)blank-sensing monotonic #-context-free 9

rules and (non-)blank-sensing erasing rules? Obviously, we can sharpen our result as follows: Corollary 4. For array grammars of dimension d > 1 containing only nonblank-sensing monotonic #-context-free rules and non-blank-sensing erasing #context-free rules, the membership problem is already undecidable. Proof. We follow the lines of our main theorem and split each blank-sensing erasing #-context-free rule p = (W; A1 ; A2 ) into two productions p0 and p00 , where the former rule is a non-blank-sensing monotonic #-context-free production and the latter one a non-blank-sensing erasing one:

p0 = (W; A1 ; f (v; Z ) j v 2 W g) and p00 = (f dg; f( d; Z )g; f( d; #)g); where Z is a new nonterminal. For example, in case of the erasing rule # X L ! # # speci ed in the E-mode, we obtain the rules # X L ! Z Z and Z ! # .

This shows that even in case of non-blank-sensing monotonic #-contextfree rules and non-blank-sensing erasing #-context-free rules we can generate non-recursive languages. 2 Remark. Analyzing our proofs of undecidability further, one sees that the erasing-rule-free normal form well-known from the context-free string case does not exist in the array setting. The essence of the previous proof lies in the presence of erasing rules. By Morita, Yamamoto, and Sugata [11] it is known that the membership problem for non-blank-sensing monotonic #-context-free languages is NP-complete (observe that here erasing rules are not present). The following theorem sharpens this result to the case of blank-sensing monotonic #-context-free rules. Theorem 5. For array grammars of dimension d > 1 containing only (possibly) blank-sensing monotonic #-context-free rules, the xed and general membership problem is NP-complete. Proof. The hardness carries over from [11]. Thus, containment within NP has to be shown. For an NP algorithm, the crucial point is to observe that the only problematic rules which might destroy the polynomial bound on the length of a derivation are monotonic chain rules. Here one can show that for such a #context-free array grammar G with production set P we get: If A1 `G A2 `G A3 and card(shape(A1 )) = card(shape(A2 )) < card(shape(A3 )), then A3 is derivable from A1 in at most (card(P ) ? 1)
card(shape(A1 )) + 1 steps. Otherwise, one has run into a cycle of applications of monotonic chain rules. Therefore, the whole number of derivation steps to produce a terminal array is polynomially bounded. 2

10

5 Conclusions and Prospects We have shown that #-context-free two-dimensional array languages include all recursively enumerable one-dimensional array languages, which reveals an astonishingly high generative power of this model. Moreover, we have tried to classify the boundary of the undecidable for these grammars. Nevertheless, some problems and questions within this context remain unanswered. The one-dimensional case is somehow special and poses interesting open questions. It is known that one can have \non-context-free" eects (compared to the string case, see [6]), but the exact status of the membership problem is open for #-context-free one-dimensional array languages. The corresponding problem for quasi-monotonic #-context-free d-dimensional array languages remains another interesting open question, even in the case when blank-sensing rules are forbidden. Observe that d-dimensional array languages with arbitrary quasi-monotonic rules are computationally universal (in contrast to the string case). On the other hand, if we stick to monotonic nonblank-sensing #-context-free rules, we can even impose some sort of regulation (for example matrix grammars of nite index) and still have an NP algorithm for the membership problem, see [2]. Here again we can ask: where is the boundary between the decidable and the undecidable? Finally, let us mention that there are dierent approaches to syntactical description of multi-dimensional objects, see [7, 8]. One such approach to pictures are chain-code picture languages [3, 10]. They can be seen as de ned by array grammars with a unary terminal alphabet and the possibility to \move through" already known terrain again. Also in this case, NP-completeness of the ( xed and general) membership problem for regular and context-free chain-code pictures has been shown by Kim, Sudborough and Welzl [9, 14]. We remark that enhancing the vocabulary of chain codes by a \rubber mode" one can show by a technique quite similar to the one presented in the main result of this paper that the (picture) membership problem is undecidable even for regular rubber chain code languages. Moreover, there obviously exist relatively simple \translations" between various picture describing mechanisms. Such translations can be used to alleviate hardness and (un)decidability proofs considerably.

References [1] C. R. Cook and P. S.-P. Wang. A Chomsky hierarchy of isotonic array grammars and languages. Computer Graphics and Image Processing, 8:144{ 152, 1978. [2] H. Fernau, R. Freund, and M. Holzer. Regulated array grammars of nite index. To appear in: Gh. Paun and A. Salomaa (eds.), Grammatical Models of Multi-Agent Systems, 1998. 11

[3] H. Freeman. On the encoding of arbitrary geometric con gurations. Transactions on Electronic Computers, 10:260{268, June 1961. [4] R. Freund. Aspects of n-dimensional Lindenmayer systems. In: G. Rozenberg and A. Salomaa (eds.), DLT'93, pp. 250{261. Singapore, 1994. [5] R. Freund. Control mechanisms on #-context-free array grammars. In: Gh. Paun (ed.), Mathematical Aspects of Natural and Formal Languages, pp. 97{137. Singapore, 1994. [6] R. Freund and Gh. Paun. One-dimensional matrix array grammars. J. Inf. Process. Cybern. EIK, 29(6):1{18, 1993. [7] K. S. Fu. Syntactic Pattern Recognition, Applications, pp. 1{30. Berlin, 1977. [8] K. Inoue and I. Takanami. A survey of two-dimensional automata theory. In: J. Dassow and J. Kelemen (eds.), IMYCS'88, LNCS 381, pp. 72{91, 1988. [9] C. Kim and I. H. Sudborough. The membership and equivalence problems for picture languages. Theoretical Computer Science, 52:177{191, 1987. [10] H. A. Maurer, G. Rozenberg, and E. Welzl. Using string languages to describe picture languages. Information and Control, 54:155{185, 1982. [11] K. Morita, Y. Yamamoto, and K. Sugata. The complexity of some decision problems about two-dimensional array grammars. Information Sciences, 30:241{262, 1983. [12] A. Rosenfeld. Isometric grammars, parallel grammars and picture grammars, volume 6 of Machine Intelligence, pp. 281{294. Edinburgh, 1971. [13] A. Rosenfeld. Picture languages. Reading, MA, 1979. [14] I. H. Sudborough and E. Welzl. Complexity and decidability for chain code picture languages. Theoretical Computer Science, 36:173{202, 1985. [15] P. S.-P. Wang. Some new results on isotonic array grammars. Information Processing Letters, 10:129{131, 1980. [16] Y. Yamamoto, K. Morita, and K. Sugata. Context-sensitivity of twodimensional regular array grammars. International Journal of Pattern Recognition and Arti cial Intelligence, 3:295{319, 1989. [17] E. Yodogawa. A note on array grammars. Information Processing Letters, 18:51{54, 1984. 12