Towards Database Optimization by Evolution P. van Bommel
Th.P. van der Weidey
Published as: P. van Bommel and Th.P. van der Weide. Towards Database Optimization by Evolution. In Proceedings of the International Conference on Information Systems and Management of Data (CISMOD 92), Bangalore, India, pages 273{287, July 1992.
Abstract
In this paper we focus on optimization of database schema transformation, by evolutionary (or genetic) search. A framework for transforming conceptual data schemata into ecient internal schemata is presented. We consider this problem from the viewpoint of searching through the space of all correct, but possibly incomplete internal representations of the conceptual schema at hand. A search strategy is established, based on the use of evolutionary operators. The relevant evolutionary operators are introduced.
1 Introduction During the development of an information system, the process of database design is usually preceded by the process of information analysis. The result of information analysis is a conceptual schema, specifying what kind of data must be stored. Then, the process of database design is initiated with this conceptual schema. It results in an internal schema, specifying in what way the data is represented on a computer (see also [11]). For a given conceptual schema, the number of correct internal representations may be very large. Some internal schemata will result in an ecient system, others will not. The problem then is how to nd good candidate internal schemata. In this paper we focus on the question how such a good candidate schema can be found, based on the notion of evolution. For other approaches, see for example [1], [3], [15], [19]. The concept of evolution was introduced in the context of formal (technical) systems twenty years ago ([18], [10]). Since then, this concept has become more powerful by a further formalization of biological evolution (e.g. [8], [22]). In so-called evolutionary (or genetic) algorithms, optimization is expressed as the evolution of (a group of) individuals with weak properties into (a group of) individuals with strong properties (e.g. [6], [12]). Recently, this approach has been applied in a number of elds, for instance aircraft design, chemistry, neural network architectures and telecommunication networks (see [6]). Evolutionary methods can be made very robust in avoiding local optima. This robustness is obtained by searching from a set of solutions, instead of one single solution, on the basis of probabilistic reproduction rules, rather than deterministic rules. The evolutionary optimization can be based on a suitable problem representation, with only a limited set of primitive operations (see e.g. [6], [8], [12], [13] and [22]). The behaviour of the optimization process can then be derived from the behaviour of these primitive operations (see [8]). Dept. of Information Systems, Faculty of Mathematics and Informatics, University of Nijmegen, Toernooiveld 1, 6525 ED Nijmegen, The Netherlands, E-mail:
[email protected] y This work has been partially supported by the ESPRIT project APPED (2499).
1
In this paper we restrict ourselves to (the broad class of) conceptual modelling techniques with an underlying object-role structure (e.g. ER [4] and NIAM [14], [17]). The main contributions of this paper are: 1. De nition of candidate database structures in terms of the conceptual schema at hand, as a suitable representation for individuals. 2. Introduction of evolution operators in terms of this internal representation.
We give a global description of (simple) evolution strategies for database optimization. In this approach, we search the space of internal representations, using reproduction operators for database structures. The organisation of this paper is as follows. In section 2 we shortly introduce a general objectrole platform, called the Predicator Model. In section 3 we introduce internal representations, followed in section 4 by a function for estimating the average storage requirements for individuals. In section 5 we set the context for the optimization of these internal representations and de ne the search space of individuals. In section 6 we discuss the reproduction (evolution) of individuals. With respect to the graphical representation of conceptual information structures, we make use of the NIAM drawing convention (see [17]). For the internal representations, we introduce an extension of this convention.
2 The Predicator Model
In the Predicator Model a schema = hI ; Ci consists of an information structure I and a set of constraints C . The semantics of a schema are expressed in terms of populations (instantiations) of the information structure, satisfying the requirements speci ed in C . For a formal de nition of these concepts, we refer to [2]. We shortly summarize them in this section.
C
A
p
a1
f
q b1
g s B
r
t
b1 c1 b1 c2 b1 c2
d1 d1 d2
D
u
d1 d2
h
v e1 e1
E
Figure 1: Example information structure with population An information structure consists of the following basic components: A set O of object types. For example, in gure 1 we have A 2 O. A set P of predicators. A predicator is intended to model the connection between an object type and a role. In gure 1 for example we have p 2 P . The associated object type is found by the operator Base : P ! O . A set of fact types F , de ned as a partition of P . In gure 1 we have F = ff; g; hg and f = fp; qg. Fact types are treated as object types: F O. The object types in A = O ? F are called atomic object types. Fact types can be populated with instances (or tuples). In gure 1 we see hd1; e1 i as an instance of fact type h. 2
We call predicators p and q attached to each other, denoted p q, if they have the same base. The fact type that corresponds with a predicator is obtained by the operator Fact : P ! F , de ned by: Fact(p) = f , p 2 f. A predicator p is called an objecti cation, if it is based on a fact type: Base(p) 2 F . The set H contains all objecti cations: H = p 2 P j Base(p) 2 F .
3 Tree representations In this section we introduce the nested relational view on information structures (see [5], [20] and [21]), as an extension of the Predicator Model in terms of an additional structuring of predicators. This (internal) view directly corresponds to an implementation structure of the (conceptual) information structure. Such a nested view is called a forest in the sequel.
3.1 Basics
A forest (set of trees) T = hN ; E; `i is called an incomplete tree representation of information structure I , denoted as Forest(T; I ), if it satis es the following wellformedness conditions: t1 : Each node n in N is a set of di erent, mutually attached predicators. The common base of these predicators is denoted as Base(n). Note that not all predicators need to participate in this partial partition of P . t2 : All predicators in a node belong to di erent fact types. t3 : A node may contain at most one objecti cation (element of H). t4 : E N N is a set of edges. The pair hm; ni represents an edge from node m to node n. Since T is a set of trees, each node has at most one outgoing edge. t5 : Edges are labelled by fact types in the obvious way, with some care to handle objecti cation. The function ` : E ! F assigns ` (hm; ni) = f, i : 1. the destination node contains a predicator from f (n \ f 6= ;). 2. only in case of an objecti cation, the source node may not contain a predicator from f (m \ f = ; ) Base(m) = f). t6 : Fact types are located around a single parent: `(hm1 ; n1i) = `(hm2 ; n2i) ) n1 = n2 We call tree representation T complete, denoted as CompleteForest(T; I ), if each predicator is involved in some node: S t7 : N = P As a consequence, in a complete representation the set of nodes N is a (complete) partition of the set of predicators P .
Example 3.1 In gure 2 we see a complete tree representation of the information structure in gure 1.
The relation between nodes and edges is directly coupled to predicators. The predicators form the anchors that catch the edges onto the nodes. From properties t2 and t5 we see that an edge hm; ni is anchored to a unique predicator p 2 m, with p 2 hm; ni): Lemma 3.1 Let e = hm; ni be an edge and let `(e) = f . If node m has an atomic base, then: jm \ f j = 1 3
' B $ q r ?@
% n& 1
I @ 6 ? @ ? f? g @ g @ ? @ ? $ ' '$ '
$
A p C s D t % % u n& n& 2 3 n& 4
%
h
6
'$ E v % n& 5 Figure 2: Example tree representation
Proof: Let hm; ni 2 E with Base(m) 2 A and `(hm; ni) = f. From condition t5 we conclude that m\f = 6 ;. Now the result can be obtained from condition t2 .
2 This unique predicator is denoted Anchor(m). For the nodes, being the destination of some edge, an analogous property holds: Lemma 3.2 Edge e = hm; ni with `(e) = f has the following property: jn \ f j = 1. For fact type f this unique predicator is denoted Hook(f). The empty forest is de ned as " = h;; ;; ;i. It has the following property: Lemma 3.3 For every information structure I we have: Forest("; I ): We de ne R N as the set of nodes being the root of some tree: R = x 2 N 8 m;n E [x 6= m] h
i2
3.2 Trees as nested relations
The tree representation of an information structure is very close to the concept of nested relations, as introduced in [5], [20] and [21]. In order to demonstrate this, we show in this section how tree representations are translated into nested tables. Suppose node m has descendents as depicted in gure 3. We then construct a table with a column for m-values, and for each fact type hooking to node m. As a consequence, we get a nested table for each such fact type. This transformation is described by the function . The general behaviour of is shown in gure 3.
Example 3.2 The tree representation of gure 2 is translated into the following nested relational structure:
n1
f g n2 n3 n4
h n5 4
m I AK@ ?
!
(m) = m (n11 )
! ? A@ A @ ? A fk@ fk f1 ? f1 A @ ? @ A ? @ A ? @ A ? @ A ?
n
n1l
11 1
n
nkl
f1
(n1l1 )
(nk1 )
fk
(nkl )
k1
k
Figure 3: Translation into nested relations
4 Populations In this section we discuss populations (instantiations) of information structures, tree representations, and their relation. We will see that our translation mechanism leads to a correct implementation of the corresponding information structure. The notion of correct implementation in the context of informaton structures is introduced in [9]. We rst shortly discuss the population of information structures (4.1). Then we introduce populations for tree representations (4.2). Next, we show how a conceptual population (of an information structure) is translated into an internal population (of a tree representation) (4.3). Finally, we give an upperbound for the storage requirements of a tree representation, in terms of the population of the corresponding information structure (4.4).
4.1 Information structure population
A population Pop of an information structure I assigns to each object type in O a set of values of some universal domain ([16]), conforming to the structure as prescribed by P and F . The population of an atomic object type is just a set of values. The population of a composed object type (fact type) is a set of tuples. A tuple t of a fact type f is a mapping of all its predicators to values of the appropriate type:
8f 8t Pop(f ) 8p f [t(p) 2 Pop(Base(p))] 2F
2
2
This is referred to as the Conformity Rule.
Example 4.1 Consider the information structure from gure 1. We see that the population of object type A contains one value a1. Furthermore, the population of fact type f contains one tuple f(p; a1); (q; b1)g. Note that the entire population satis es the Conformity Rule.
4.2 Tree population
In this section we introduce how tree representations are populated. Our way of populating tree representations is analogous with [5], [20] and [21], where the population of a nested relation consists of nested tuples. We describe such tuples in terms of nodes in the forest. A population P of a tree representation T assigns to each node in N a set of values of the corresponding domain. Let m 2 N be a node. Then, a population P(m) is a set of tuples, where each tuple assigns a unique value to m:
8t1 ;t2 P(m) [t1(m) = t2 (m) ) t1 = t2 ] 2
5
k
This is referred to as the Partitioning Rule for populations (cf. [20]). The value t(m) is called the root value of tuple t. Furthermore, a tuple t 2 P(m) assigns to each descendant of node m a value, organised via the subtables structure resulting from the transformation . Let f be an attribute of table (m) with schema fn1; :::; nlg. Then, each ht1 ; :::; tli 2 t(f) should t in the population of the corresponding children: 81 i l [ti 2 P(ni )] This is referred to as the Fitting Rule. The Partitioning Rule and the Fitting Rule establish the basis for the mapping of populations from the conceptual level to the internal level.
4.3 Transformation of populations
In this section we consider the translation of a conceptual population (of an information structure) into an internal population (of a tree representation). Let I be an information structure and let T be a tree representation of I . Furthermore, let Pop be a population of I . From the population Pop we will construct a population P of the tree representation T. Let m be a node in T. Then, for each instance of the corresponding base a (unique) tuple will result in P(m): Pop(Base(m)) = t(m) j t 2 P(m) This rule is referred to as the Base Representation Rule. Next we consider the subtables of (m). Let f be an attribute of (m) with schema fn1 ; :::; nlg, hooked by p (see lemma 3.2). Then the internal representation of f ful ls the following rule: t 2 P(m) ) t(f) = x[n1; :::; nl] j x 2 Pop(f) ^ x(p) = t(m) This is referred to as the Fact Representation Rule. This rule concludes the transformation from Pop into P. Obviously, P satis es the Partitioning Rule and the Fitting Rule. A next property is: Lemma 4.1 Forest(T; I ) ) (T) is a correct implementation of I . For a formal de nition of the concept of correct implementation we refer to [9]. It will however also be clear that schemata I and (T) are not equivalent. For this purpose schema (T) should at least be extended with a sucient set of table guards. We will not elaborate on this further in this paper. Example 4.2 Let I be the information structure from gure 1 and let T be the tree representation from gure 2. We transform the population of I into a population of T . Following our de nitions, this population will consist of one nested tuple with root value b1. The result of the transformation process is shown in gure 4.
Another (more tree-like) view of the nested tuple in gure 4 is presented in gure 5. It is obtained by lifting up root value b1 , incorporating the instances of the associated fact types (attributes in the nested table).
4.4 Population size
In this section we estimate the average size of tree populations. This size can be used for comparing tree representations with respect to their storage requirements. Let T be a forest containing node m. Let t 2 P(m) be a tuple. A local view of node m and its children is given in gure 6. We see k fact types involved in these children. Let 1 i k. The number of children associated with fact type fi is denoted as li . We use t(fi ) as a shorthand for t(ni1; :::; nil ). Then the size of tuple t is de ned by: i
Stor(t) = 1 +
X
1 i k
6
Stor(t(fi ))
n1
f g n2 n3 n4
b1
a1
h n5
c1
d1
e1
c2
d1
e1
c2
d2
e1
Figure 4: Population in nested table
f b1 g
f c1 d1
f a1 g
,
c2 d1
f e1 g
f e1 g
,
c2 d2 g
f e1 g
Figure 5: Tree-like view of population
m I A @ K A fk@ fk A @ @ A @ A @ A
?
f1 ? f1
? ? ? ?
::::: n11 : : : n1l 1
nk1 : : : nkl
Figure 6: General structure of tree
7
k
The size of t(fi ) is recursively found, by the summation over all tuples in t(fi ): Stor(t(fi )) =
1X j li
ht1 ;:::;t i
t(fi )
Stor(tj )
li 2
Example 4.3 Let t be the nested tuple shown in gure 5. We then have Stor(t) = 11. The size of population P(m) is expressed in terms of the tuples it contains: Stor(m) =
X
t2Pop(m)
Stor(t)
For tree representation T with root set R this results in: Stor(T) =
X
n2R
Stor(n)
Now, the size of P(m) can be estimated using the number of fact instances in the conceptual population Pop:
Lemma 4.2
Stor(m) jP(m)j
1X j li
1 i k
jPop(fi )j Stor(nij )
Proof: The number of tuples in P(m) is jP(m)j. Let t be such a tuple, de ned as a function on m; n11; :::; nkl . From the Fact Representation Rule we know that the number of assignations by t to nij (for 1 j li ) is at most jPop(fi )j (for 1 i k). From this the result is k
derived.
2
Example 4.4 For the tree in gure 2 this results in: Stor(n5 ) Stor(n4 ) Stor(n3 ) Stor(n2 ) Stor(n1 )
1 4 2 1 19 Note that this lemma gives a rather pessimistic upperbound, since it is based on the number of tuples in the population of fact types. For a more accurate estimation such a fact type should be projected on its hook (see lemma 3.2). Then, the component jPop(f)j in lemma 4.2 is replaced by Pop(Hook(f ) f) .
5 Optimization by evolution It will be convenient to base the search space for an optimal internal schema for a given information structure I , on all tree representations T, such that Forest(T; I ). So, we explicitly allow incomplete representations, in order to make the search space more easily traversable, i.e., by more simple operations. Elements of this search space are also called individuals or solutions. Each individual of this search space has a certain tness. This is speci ed by a tness function that (in our case) will take into account the expected storage requirements of an individual, and the associated expected average access time: Fitness(T) = f(Stor(T); Time(T)) 8
where Stor speci es the storage space of an individual (see previous section) and Time speci es the expected average access time. The computation of the average access time Time will be based on a proper transaction pro le in the obvious way. This will not be discussed further in this paper. The database optimization problem is now formulated as: For a given information structure I , nd a complete forest T that optimizes the function Fitness.
A simple approach is to nd the maximum by an exhaustive search. As the search space might be quite large (a pessimistic upperbound is 2jP j+1 ? 1), this approach is not of practical value. A better approach is to use good heuristics to nd the optimal individual. The typical problem of this approach, however, is to avoid local optima. For an in-depth study of global optimization approaches, we refer to [24]. One approach exploits the idea of evolution of individuals (see [6], [8], [12], [13] and [22]). In general, evolution of individuals is described as follows: Given a set of individuals fT1 ; :::; Tig, nd a new individual T that combines the strong properties of T1; :::; Ti. In analogy with evolution processes in the real world (e.g. biology), evolution of individuals is based on the following two operations: mutation and crossover. We will discuss both operations in more detail. Mutation is an operation that changes some of the properties of an individual T to produce a new individual T . In order to avoid local optima, the selection for which properties to change, and how, are made non-deterministically, i.e. randomly or probabilistically, in such a way, that small mutations are more likely to occur than larger mutations. A simple mutation-based search strategy tries small mutations as long as possible. This is called local optimization. If small mutations do not produce better individuals, larger mutations are tried (global optimization): 0
if a higher Fitness can be found by a small mutation then perform small mutation else perform large mutation end
In more advanced search strategies, reproduction of individuals is de ned in terms of the crossover operation. Given two individuals T1 and T2 , a crossover produces a new individual T that has some properties in common with its parents T1 and T2 . Usually, such a crossover is performed on individuals with a high tness: 0
for two individuals with high Fitness do perform crossover
This strategy is applied in so-called Genetic Algorithms (e.g. [8]), where the individuals to be combined (crossed) are selected tness-proportionately from a set of individuals. In this way, the notions of 'natural selection' and 'survival of the ttest' are simulated. For more details, we refer to [6], [8], [12], [13] and [22].
6 Reproduction of individuals In this section, we introduce the primitive operations on individuals, that are necessary for describing the search strategies from the previous section.
6.1 Merging of individuals
As a rst operation we introduce the union of two disjoint individuals (i.e., having no predicators in common), denoted as . This merging is performed by simply uniting the separate components of the individuals: nodes, edges and labelling. 9
6.2 Promotion
The next operation generates a variation of an individual by promoting a given node upto the root of its tree. The shape of the tree is changed in a consistent manner: the result of (T; n) is a tree representation with the same set of nodes, only some edges redirected, and all labels una ected. In order to de ne the new set of edges, we consider the edges on the path from node n to the root of the tree: E = hx; yi 2 E j n ! x In (T; n) the edges in E are replaced by their reversal: hy; xi j hx; yi 2 E . Furthermore, the edges labelled with the same fact type as the edges in E should be redirected. Let F be the set containing these fact types, de ned as: 0
0
0
0
F = f 2 F j 9e E [`(e) = f] Then the edges in e 2 E ? E j `(e) 2 F should be replaced by the edges: 0
2
0
hy; xi y 6= x ^ 9 x;z h
E
i2
0
[`(hy; z i) 2 F]
Example 6.1 Consider node n3 in the tree representation T in gure 2. The result of (T; n3 ) is given in gure 7. ' C $ s &%
@ I g ?? @g
?
? '
@
@ $ '
B r q & f
6
D t u
% & h
6
$ %
'$'$ A p E v % &%& Figure 7: Promoting node fsg upto the root
6.3 Pruning
The prune operation cuts o a part of an individual. The cutting is produced by the function , the remainder of the individual by the function . In genetic terms, this corresponds to isolating ( ) and removing ( ) a set of properties from an individual. The base of a cutting is a predicator, that should however be a valid cutting point, i.e. the hook of its associated fact type. Note that the fact type will be completely disconnected from the accomodating node. We describe the remainder function detailed, the cutting function can be handled analogously (see gure 8). 10
' B $ q r ?@
&%
I 6@ ? (T; u) (T; u) @ ? f? g @ g @ ? @ ? $ ' '$ ' $
A p C s D t ' D $ % % % u & & & &% h
6
'$ E v % & Figure 8: Pruning Let T = hN; E; `i be an individual and let p be a valid cutting point with n = Node (p) and f = Fact(p). The remainder of T after cutting in predicator p is the individual (T; p) described by: nodes: N ? D(T; n; f) ? fng [ fn ? fpgg edges: E ? V (T; n; f) labels: the labelling function is restricted to the relevant edges. where D(T; n; f) is the set of descendants de ned as: x j x ! z ! n ^ `(hz; ni) = f and V (T; n; f) is the set of vertices de ned as: hx; yi j x ! z ! n ^ `(hz; ni) = f : If the point of application p is not the hook of its associated fact type, or does not even occur in the individual, the cutting operator yields the empty forest ".
Lemma 6.1 Each cutting is alive, and the remaining individual is not killed: Forest(T; I ) ) Forest( (T; p) (T; p); I )
6.4 Grafting
The graft operator is an inverse function to the - pruning system. Suppose we have, on the one hand, an individual T1 and a node n in this individual as an application point for grafting. On the other hand, we have an individual T2 and a cutting point p. If node n and predicator p are attached to each other, then (T1 ; n; T2; p) results in an individual that has (T2 ; p) grafted into node n. This individual consists of all nodes from T1 , with node n changed into n [ fpg, plus all nodes in the subtree of predicator p in the second individual (D(T2 ; Node(p); Fact(p))). These nodes are connected by all edges from T1 , with the modi cation of the outgoing edge of n into an outgoing edge for n [ fpg. These are augmented with the edges that link the cutting into the grafting point ( h x; n [ f p gi j h x; Node (p) i 2 E ), and with the edges from T2 lower in 2 the subtree of p ( hx; yi 2 E2 j y 2 D(T2 ; Node(p); Fact(p) ). 11
The inherited edges keep their labels from T1 and T2 , while the new edges are labelled according to their origin in E2. We allow n to be the empty node. In that case the above de nition is still valid. Analogous with lemma 6.1, the graft operation yields proper individuals. Let n be a node in T1 and p be a valid cutting point in T2 with the same base.
Lemma 6.2
Forest(T1 ; I ) ^ Forest(T2 ; I ) ) Forest( (T1 ; n; T2; p); I )
The soundness of the graft operation is expressed by the fact that grafting restores pruning:
Lemma 6.3 T = ( (T; p); Node (p) ? fpg ; (T; p); p)
6.5 Crossover
A special application of the prune and graft operators is the so-called crossover operator (recombination), which replaces a cutting from T1 by a cutting from T2 . Using the operators from the previous sections, we can de ne this operator by: (T1 ; p1; T2; p2) = ( (T1 ; p1); Node(p1 ) ? fp1g ; T2; p2)
6.6 Mutation
Another special application of pruning and grafting is the so-called mutate operator, which restructures an individual by the manipulation of substrees. It cuts o a subtree from an individual and grafts this subtree into (another) node. This operator is de ned by: (T; p; q) = ( (T; q); p; T; q)
7 Conclusions
In this paper we presented a framework for the optimization of database structures. This optimization was initiated by a conceptual schema, speci ed in the Predicator Model. Then an evolution of internal representations was de ned, on the basis of non-deterministic reproduction rules. The Predicator Model and the evolution of database structures is currently being implemented. Empirical research will be used for the further re nement of this approach. We recognize the following directions for further research: 1. A further theoretical foundation of evolutionary (or genetic) search for database structures. The attention should be focussed on the following question: Given two individuals T1 and T2 , what is the expected tness of their crossover individuals, and how can this crossover be guided to yield an optimal candidate?
2. A generalization of our approach. Firstly, the computation of access time should be investigated, given an expected pro le of access operations. Secondly, access paths (indices) should be integrated in the individuals. 3. Application of the approach in the optimization of CD-ROM databases (e.g. Hypertext [23]). This will be partly supported by the ESPRIT project APPED (2499). 4. Application of the approach in the implementation of so-called Evolving Information Systems (EIS [7]). The EIS project is partly supported by the Foundation for Computer Science in The Netherlands (SION). 12
Acknowledgement
The use of an evolutionary approach in database optimization was suggested by E.D. Falkenberg. We thank the anonymous referees for their contributive remarks.
References [1] A. Amikam. On the automatic generation of optimal internal schemata. Information Systems, 10(1):37{45, 1985. [2] P. van Bommel, A.H.M. ter Hofstede, and Th.P. van der Weide. Semantics and veri cation of object-role models. Information Systems, 16(5), October 1991. [3] M.A. Casanova, L. Tucherman, A.L. Furtado, and A.P. Braga. Optimization of relational schemas containing inclusion dependencies. In Proceedings of the Fifteenth VLDB Conference, pages 317{325, 1989. [4] P.P. Chen. The entity-relationship model: toward a uni ed view of data. ACM Transactions on Database Systems, 1(1):9{36, 1976. [5] L.S. Colby. A recursive algebra for nested relations. Information Systems, 15(5):567{582, 1990. [6] L. Davis. Handbook of genetic algorithms. Van Nostrand Reinhold, New York, 1991. [7] E.D. Falkenberg, J.L.H. Oei, and H.A. Proper. A conceptual framework for evolving information systems. In The Second International Working Conference on Dynamic Modelling of Information Systems, Washington DC, July 1991. [8] D.E. Goldberg. Genetic algorithms in search, optimization, and machine learning. AddisonWesley Publishing Company, Inc., 1989. [9] A.H.M. ter Hofstede and Th.P. van der Weide. Expressiveness in Data Modelling. Technical Report 91/07, SERC, Software Engineering Research Centrum, Utrecht, The Netherlands, July 1991. [10] J.H. Holland. Adaption in Natural and Arti cial Systems. University of Michigan Press, 1975. [11] ISO/TC97/SC5/WG3. Concepts and Terminology for the Conceptual Schema and the Information Base, 1982. [12] K. de Jong. Genetic algorithms: A 10 year perspective. In Proceedings of the rst International Conference on Genetic Algorithms and their Applications, pages 169 { 177, 1985. [13] K. de Jong. On using genetic algorithms to search program spaces. In Proceedings of the 2nd International Conference on Genetic Algorithms and their Applications, pages 210{216, 1987. [14] C.M.R. Leung and G.M. Nijssen. Relational database design using the NIAM conceptual schema. Information Systems, 13(2):219{227, 1988. [15] M.E. McLaughlin, K.B. Bates Hill, D.D. Brown, M.A Rogers, Howell A.M., and Hatch P.P. An integrated methodology and toolset for database design. ACM SIGMOD Record, 17(4):37{55, 1988. [16] E. Mendelson. Introduction to Mathematical Logic. Wadsworth and Brooks, 1987. [17] G.M. Nijssen and T.A. Halpin. Conceptual schema and Relational Database Design: A fact oriented approach. Prentice Hall of Australia Pty Ltd, 1989. 13
[18] I. Rechenberg. Optimierung technischer Systeme nach Prinzipien der biologischen Evolution. PhD thesis, Technical University of Berlin, Germany, 1970. [19] N. Rishe. Ecient organisation of semantic databases. In W. Litwin and H.J. Schek, editors, Foundations of Data Organisation and Algorithms (FODO-89), volume 367 of Lecture Notes in Computer Science, pages 114{127. Springer Verlag, 1989. [20] M.A. Roth, H.F. Korth, and A. Silberschatz. Extended algebra and calculus for nested relational databases. ACM Transactions on Database Systems, 13(4):389{417, December 1988. [21] H.J. Schek and M.H. Scholl. The relational model with relation-valued attributes. Information Systems, 11(2):137{147, 1986. [22] H.P. Schwefel. Numerical Optimization of Computer Models. John Wiley and Sons, 1981. [23] P.L. van der Spiegel, J.T.W. Driessen, P.D. Bruza, and Th.P. van der Weide. A Transaction Model for Hypertext. In Proceedings of the Data Base and Expert System Applications Conference (DEXA 91), pages 281{286. Springer Verlag, 1991. [24] A. Torn and A. Zilinskas. Global Optimization. Springer Verlag, 1989.
14
