[Haskell-cafe] [Haskell] ANNOUNCE: genprog-0.1
Alberto G. Corona
agocorona at gmail.com
Thu Dec 9 13:48:39 CET 2010
2010/12/9 Ketil Malde <ketil at malde.org>
> Mitar <mmitar at gmail.com> writes:
> >> Neither Haskell nor any conventional language has [evolved to evolve]
> > True.
> Well - thinking about it, there's no fundamental difference between
> genetic algorithms - where you have a "genome" in the form of a set of
> parameters and genetic programming - where the "genome" is a program of
> some sort, typically Lisp code, since the syntax tree is so accessible
> and malleable.
> In either case, you have an interpreter that interprets the genome, the
> difference is mainly in the expressive power of the language. I haven't
> looked closely, but I suspect you might not want Turing-completeness in
> either case (Alberto?
I´m not sure. (answer at the bottom). There are some characteristics on DNA
code that are there just to evolve some parts of the code while maintaining
safe some others. There are sequences that are extraordinarily stable for
millions of years across species, while others change very often. Some
others are in the middle. This is not arbitrary. Let´s say that the stable
parts are the IF statements while the changing parts are the parameter
values. Doing so, the species explores the safe part of the fitness
landscape without wasting effort in experiments that have 99% chance to
Females will evolve whatever mechanism to avoid these experiments as soon as
However risky experiments shoud be taken from time to time, to explore new
zones of the fitness landscape.
Another characteristic of evolution, is its multilevel nature. There are
selection of genes. Selection of gene replication alternatives, selection of
reproduction alternatives. procariotic, eucariotic, multicelular
(individual), social levels of selection.
Not only that. During ovulation there is a selection of good eggs, as I
mentioned. And this selection is related with the stability of critical gene
sequences. this test for stability is regulated by other supervisor genes
that test with different degrees of accuracy the absence of mutations in
these protected sequences. This internal checking for consistency can be
considered a level of selection, or autoselection if you like. . selective
checking has evolved as a metalevel. But you can alternatively consider this
consistency check as a set of rules written in the genetic code by
selection itself . Rules are a form ofselection mechanisms after all.
All of these "Rules" have evolved because the genetic code executes over
itself using its own code as data: Some genes activate others. some others
check for absence of mutations and so on. That is, some metalevel selection
are carried out by the same code that is evolving. Moreover some rules are
different for each genera or specie son it is not possible to extract (and
abstract) out certain chekings from the code that is checked.
If evolution is search for local maximums in a tree, the rules/metalevels
are heuristic rules that guide the strategy of exploration.
> But yes, by designing the language to evolve, we can get a head start
> compared to nature.
What means what I said above for evolving programs? First that a simple
genetic algorithm operating on auto modifying code can generate any solution
if we wait a few billion of years. But we can help to do it faster by
studying the DNA code, learn their already evolved techniques and use them
to design languages, assign rates of mutation for each statement, discover
rules, selection mechanism, species of programs (or design patterns) that
acts as templates for each problem etc.
Species of programs means that the seed of the genetic algoritm must not be
turing comoplete I guess. It must be specific for each problem.
> If I haven't seen further, it is by standing in the footprints of giants
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe