Controlled Fuzzy Parallel Rewriting
Peter R. J. ASVELD
Department of Computer Science
Twente University of Technology
P.O. Box 217, 7500 AE Enschede, The Netherlands
E-m~il: infprj a9 utwente, nl
Abstract. We study a Lindenmayer-like parallel rewriting system to
model the growth of filaments (arrays of cells) in which developmental
errors may occur. In essence this model is the fuzzy analogue of the
derivation-controlled iteration grammar. Under minor assumptions on the
family of control languages and on the family of fuzzy languages in the
underlying iteration grammar, we show that (i) regular control does not
provide additional generating power to the model, (ii) the number of fuzzy
substitutions in the underlying iteration grammar can be reduced to two,
and (iii) the resulting family of fuzzy languages possesses strong closure
properties, viz. it is a full hyper-AFFL, i.e., a hyper-algebraically closed
full Abstract Family of Fuzzy Languages.
1. Introduction
The original motivation to introduce Lindenmayer systems, or L-systems for short,
consisted of modeling the development of filamentous organisms [15], [16]. The state
space of each individual cell of such an organism is a finite set, symbolically represented
as an alphabet V, and rewrite rules over V provide for the development of single cells.
More precisely, a rule c~ -+ w with ~ ~ V and w E V*, allows for a state change
(w C V, w ~ ~), a cell death (w = ~, t is the empty word), or the splitting of a
cell in more than a single off-spring (I w I> 1, where ] w I is the length of the string
w). Starting from an initial filament, i.e. a string over V, and applying the rules
for individual cells in parallel yields the global state of the filament after a discrete
time step. Iterating this rewriting process shows the development of this filament as
function of the discrete time parameter. From a mathematical point of view the set of
rules is just a finite substitution over V that is applied iteratively to the initial string.
Subsequent contributions to the extension of this model resulted in the distinction
between nonterminal and terminal symbols as in Chomsky phrase-structure gram-
mars, in several sets of rules (several finite substitutions, also called
tables)
instead of
just a single one, and numerous ways of restricting or regulating the parallel rewriting
process. We refer the reader to [13], [21] for surveys of the early days of L-system
theory; [13] is more elementary and devoted to biological applications, whereas [21]
concentrates on mathematical properties. More recent developments and related ap-
proaches can be found in [7], [22], of which [7] treats derivation-controlled rewriting
in general, whereas [22] shows a rich variety of results closely related to or inspired
by L-systems.
The extension of the basic model with different sets of rules (a finite number of
finite substitutions instead of a single one) stems from the observation that a filamen-
tous organism might develop in a different way under different external conditions
50
[20]. A typical example is the difference between day and night; in that case we have
two sets of rules, or tables, viz. a day table 7"d and a night table Tn, each table being
a finite substitution over the alphabet V. Closely related to this extension are the
so-called derivation-controlled tabled L-systems in which the order of application is
prescribed by a control language over the table names [10], [18], [1]. E.g. in order to
obtain the right sequence of day, followed by night, followed by day, etc., a regular
control language of the form (~-dT~)*~-a can be used, provided each sequence should
start and end with the day table ~-d. Similarly, but on a larger time scale, the or-
der of the four seasons can be described by a regular control language of the form
( Tspring Tsumraer Tautmnn Twinter ) * rspring.
In this paper we introduce a further extension of this model which enables us
to describe developmental errors. Such an error occurs when, instead of applying
the correct rule a -+ w from the table T, the symbol a is replaced by a string w ~
with w J # w and a -+ w ~ is
not
a rule in r. In such a situation the "quality" of
this incorrect off-spring w ~ should be strictly less than the corresponding correct one
and, consequently, the "quality" of the entire filament should also decrease by this
developmental error. In addition we want that making two developmental errors is
worse than a single error and, in general, that each additional developmentM error
should strictly decrease the "quality" of the filament under consideration.
But how do we measure the "quality" of a string or filament x derived by a
controlled tabled L-system G? In traditional formal language theory there only are
two possibilities, viz. (i) x belongs to the language
L(G)
generated by G: its "quality"
equals 100%, or (ii) x does not belong to L(G): the "quality" of x is 0%. Clearly,
there is no room for expressing statements like "x is slightly imperfect due to a
minor developmental error" or "x has been severely damaged by a long sequence of
considerable errors during its development". This lack of expressibility is, of course,
due to restrictions in set theory: the membership function or characteristic function
#L(a) of a set, or a language
L(G)
in our case, has two possible values only:
~tL(G)(X ) =
1 if x E L(G), and
#L(a)(x)
= 0 if
x ~ L(G).
Thus, if
L(G) C E*,
then
#L(a}
is a
mapping of type
#L(a)
: E* --+ {0, 1}.
Fortunately, using fuzzy sets and fuzzy languages we are able to express "qualities"
different from 0% and 100%, since
#L(a)
is now a mapping of type ttn(a) : E* ~ /2
where ~ is a complete lattice, eventually provided with additional operations and
properties. As a typical example, the reader may consider the case in which/: equals
the real interval [0,1] with min and max as lattice operations. Fuzzy languages have
been introduced in [17], which is restricted to fuzzy analogues of Chomsky grammars
and languages. In [19] fuzzy Lindenmayer systems and their languages have been
studied, however, without any motivation in terms of developmental errors. This mo-
tivation is the obvious parallel Lindenmayer variant based on the idea of grammatical
error studied in [3], [4], [5].
So in fuzzy L-system theory the "quality" of a string is a value in s which might
be anything in between 0 (the smallest element of/2) and 1 (the greatest element of
s depending on the actual structure of/:. And making a developmental error in
the derivation of x means that the "quality" of x will not increase compared to the
previous string. But whether it will strictly decrease depends on the structure and
the operations of/: as well as their relation with the definition of derivation step; cf.
Section 4 for details.
51
In dealing with developmental errors there is another problem. Usually, an L-
system has in each of its tables a finite number of rewrite rules. Making a devel-
opmental mistake, i.e., replacing a by w t instead of by the correct string w can be
modeled by adding the rule a --+ w t to the table ~" to which a --+ w belongs, and
requiring #~(~)(w') < 1, where r(a) is the set of all strings w such that a ~ w belongs
to r. This construction works for a finite number of possible developmental errors
only. But, in general, there is an infinite number of ways to make mistakes, and fila-
mentous development does not form an exception to this observation. So we should
add an infinite number of rules a ~ w t to T or, equivalently, an infinite number of
strings to the fuzzy set r(a). So each set {w E
T(a)
I 0 < #~(~)(w) < 1} is allowed to
be infinite. But then the language {w e
T(a) ]
#,(~)(W) = 1} might be infinite as well,
or, equivalently, each
T(a)
may be a fuzzy subset of V*, i.e., a fuzzy languages over
V. However, we could not let be the sets r(a) arbitrary fuzzy languages over V: they
should be restricted in some uniform way, otherwise we end up with languages
L(G)
that are not even recursively enumerable; cf. [8]. A well-known way to restrict these
fuzzy languages is the following: we require that each fuzzy language
T(a)
belongs to
a given family K of fuzzy languages. The family K is a parameter in our approach:
usually, we demand that K meets some minor conditions, but sometimes we simply
take a concrete value for K, e.g., we take K equal to the family FIN/of finite fuzzy
languages.
This results in the notion of fuzzy K-iteration grammar which plays the main
part in the present paper. Formally, such a grammar G = (V, E, U, S) consists of
an alphabet V, a terminal alphabet E (E C V), an initial symbol S (S E V - E),
and a finite set U of fuzzy K-substitutions over V. Thus for each T in U, and
for each c~ in V,
T(a)
is a fuzzy language over V that belongs to the family K.
The controlled variant of this grammar concept is the so-called F-controlled fuzzy
K-iteration grammar, or fuzzy (F, K)-iteration grammar where F is a family of (non-
fuzzy) languages. A grammar (G; M) = (V, E, U, S, M) of this type consists of a
fuzzy K-iteration grammar (V, E, U, S) and a language M over U (considered as an
alphabet) with M C F. Each derivation D according to (G; M) satisfies the condition
that the sequence of fuzzy K-substitutions used in D constitutes a string in the control
language M.
The remaining part of this paper is organized as follows. In Section 2 we introduce
the basic notions with respect to fuzzy languages and operations on fuzzy languages.
Section 3 is devoted to families of fuzzy languages. The formal definitions of fuzzy
K-iteration grammar and of F-controlled fuzzy K-iteration grammar are provided in
Section 4, where we also give a few examples of these grammars together with the fuzzy
languages that they generate. Section 5 consists of some elementary but useful prop-
erties of fuzzy K-iteration and fuzzy (F,K)-iteration grammars. The main results,
viz. Theorem 6.1 and its corollaries, which deal with the generating power of fuzzy
(F, K)-iteration grammars, are in Section 6. Closure properties of the corresponding
families of fuzzy languages are the subject of Section 7. Under minor conditions on
the families Y and K, the families
HI(K )
and HI(F , K) of fuzzy languages, generated
by fuzzy K-iteration grammars and (F, K)-iteration grammars, respectively, possess
strong closure properties very similar to the ones of the corresponding non-fuzzy lan-
guage families; cf. [1]. Finally, Section 8 contains some concluding remarks.
52
2. Fuzzy Languages and Operations on Fuzzy Languages
We assume that the reader is familiar with basic formal language theory to the
extend of the first few chapters of standard texts like [12], [14], [23]. L-systems and
Abstract Families of Languages are treated much more thoroughly in [13], [21] and [9],
respectively. Finally, we need some rudiments of lattice theory which can be found in
most books on algebra; all what we use of lattice theory is also summarized in [2].
In order to define several types of fuzziness we need a few lattice-ordered structures.
Instead of stacking adjectives, we collect some collections of properties under simple
names as
"type-bb
lattice" for some short bit strings
bb.
The following definitions and
examples are quoted from [5]. The definition of the principal notion of type 00-lattice
is a slight modification of a structure originally introduced in [11].
Definition 2.1. An algebraic structure ~ or (~, A, V, 0, 1,*) is a
type-O0 lattice
if
it satisfies the following conditions.
9 (Z~, A, V, 0, 1) is a completely distributive complete lattice. Therefore for all ai,
a, b~ and b in s aA V;b~ = V~(a A bl) and (Va~) A b =
V~(ai A b)
hold. And 0
a~d 1 are the smallest and the greatest element of s respectively; so 0 =/~ s
and 1 = V s
9 (s is a commutative semigroup.
9 The following identities hold for all
a~'s, hi's, a
and b in s
a* V~ b~ = Vi(a. bl),
(V, ai) * b =
Vi(ai.
b),
OAa=O*a=a*O=O,
1Aa= l*a = a*l =a.
A type-01 lattice
is a type-00 lattice in which the operation * coincides with the
operation A; so it is a completely distributive complete lattice actually. A
type-lO
lattice
is a type-00 lattice in which (s A, V, 0, 1) is a totally ordered set or chain, i.e.,
for all a and b in s we have a A b = a or a A b = b. In a type-10 lattice the operations
V and A are usually denoted by max and min, respectively. Finally, when Z: is both
a type-01 lattice and a type-10 lattice~ s is called a
type-11 lattice.
Example 2.2. As usual we denote the closed interval of all real numbers in
between 0 and 1 by [0, 1].
(1) The structure ([0, 1] • [0, 11, A, V, (0,0), (1, 1),*) in which the operations are
defined by (xl,yl) A
(x~,y2) = (min{xl,x2},min{yl,y2}),
(zl,Yl) V
(z2,y2) =
(max{x1, x2}, max{y1, Y2}) and
(xl,
Yl) * (x2, Y2) -- (xlx2,
YlY2)
for all Xl, x2, Yl and
y2 in [0, 1] is a type-00 lattice.
(2) Consequently, ([0,1] x [0,1], A, V, (0,0), (1, 1),,) where the operations A and V are
defined as in (1) and (xl,Yl)*
(x2,Y2) =
(min{xl,x2},min{yi,Y2})
for all Xl, x2, Yl
and y2 in [0, 1], is a type-01 lattice.
(3) The structure ([0, 1], min, max, 0,1,*) with Xl*X2 =
xlx2
for all Xl and
x2
in [0f 1]
is a type-10 lattice.
(4) Taking * equal to min in (3) yields a type-ll lattice.
53
The following useful fact is very easy to prove.
Lemma 2.3. For each type-O0 lattice s a*b < a A b holds for all elements a and
b inE.
Pro@
By the distributivity of * over V, a*(1Vb) = a*lVa*bholds. As 1Vb= 1
and a * 1 = a, we have a = a V a * b, and therefore a * b _< a. Analogously, we obtain
a* b_< b, and hence a* b <_ a A b. []
Of course, Lemma 2.3 implies that in a type-00 lattice the inequalities a * b < a
and a * b _< b also hold for all a and b.
Now we are ready to define fuzzy languages relative to the lattice-ordered struc-
tures of Definition 2.1.
Definition 2.4. Let/: be a type-00 lattice and let E be an alphabet. A/:-fuzzy
language over E is a/:-fuzzy subset of E*, i.e., it is a triple (P,, #Lo, Lo) where #Lo is
a function #Lo : E* --+ /:, the degree of membership function, and Lo is the support
of #Lo; i.e., Lo = {w e E* ] #Lo(W) > 0}. Very often we will write Lo rather than
Lo).
Henceforth, when/: is clear from the context, we use "fuzzy language" instead of
"/:-fuzzy language". Usually we write #(x; Lo) instead of #L0 (x) in order to reduce
the number of subscript levels.
For each fuzzy language Lo over E, the crisp language c(Lo) induced by Lo --also
known as the crisp part of Lo-- is the subset of E* defined by c(Lo) = {w C E* I
#(w; Lo) = 1}. Each ordinary (non-fuzzy) language Lo coincides with its crisp part
c(Lo). Therefore an ordinary language will also be called a crisp language.
In dealing with fuzzy languages (F,,#Lo,Lo) the degree of membership function
#Lo is actually the principal concept, whereas the languages L0, c(Lo) and many
other crisp languages like
L>~ = {w e E*ltt(w;Lo) >_ a} ,
n>~ = {w e E*l#(w;Lo) > a} ,
L<~ = {w e E*l#(w;Lo) _< a} ,
n<~ = {w 9 E*l#(w ;no) < a} ,
L~<;<b = {w 9 E*la < #(w;Lo) < b} ,
where a and b are elements in/:, are derived notions.
Example 2.5. (1) Let/: be the type-00 lattice of Example 2.2.(1). Consider the
/:-fuzzy language Lo over E = {a, b} defined by
)
#(ambn; Lo) = m~x{~,~,~} .... {Y,m,n} if rn, n >__ O.
In defining the degree of membership function is such a concrete case, we always
tacitly assume that #(:e;Lo) = (0,0) in all other, unmentioned cases for x in E*.
Consequently, we have, e.g., #(baa2; Lo) -- #(a2baS; Lo) = #(ab3a2b4; Lo) = (0, 0), etc.
Then the crisp part of Lo equals c(Lo) = {a'% m I m >_ 1}; for each x in c(Lo), we
have #(x; Lo) = (1, 1). Note that for each m _> 1, #(am; Lo) = (1, 0) and ~(b'~;
L0)
=
(0,1), whereas for the empty word ~, we have #(I; Lo) = (0, 0).