[stack] Re: Evolutionary Programming & presentation-format.

So much for the previous brain-storming.
Let's try some sober design/pseudo-coding.

But first, AFAICS the assumption that the goal can be incrementally approached
[i.e. not a chaotic situation] means that the goal space is continuous, in some
dimensions, in the sense that some syntactic-atoms of the language, might
monotonically change the output over some ranges.

= let the range of 'values' be {0...255} and let this be 'called' continuous.
* then, if for at least some range of some variable: stepping this variable
   will monotonically increase/decrease the output, then the goal can be
   [partially] approached by stepping this variable - until it reaches a
 discontinuity and 'flips' !

= It's difficult to imagine that/how stepping/changing the <control structures>
  could be 'continuous'.

= So it looks as if you get a set of disjoint goal-spaces.
 AFAI can remember J. Schmidhuber does these kinds of <pre adding human
 intelligence>  before he runs, and adds human input as guidance between runs.
IMO best results usually are obtained by combined human input to automata.

What are the 'canonical' elements of code and which ones could possibly give
the 'continuity' [attempted to be] described above, so that the goal
of evolution
could be approached [by intelligent hill-climbing] rather than arrived at by
random?

1. control structures : NO.
2. initialised variable/s : some of them might give a 'continuous' output over
  a certain range.
3. operators : no continuity can be expected.

AFAICS the above speculation could be tested with the very same automata:

FOR a randon set of codes

   Modify/step only one of types {initial values, controlStuctures, operators}
and record the resultant output.

Clearly this is garbage, because controlStuctures and operators canNOT be
meaninlfully ordered, and therefore cannot be 'stepped'.

Let's consider how real Darwinian evolution works?

AFAIKS the 'output' evolves towards its goal, only once the suitable
algorithm/code
already 'exists'. So at that level the code is fixed [proven] and it's iteration
moves the output towards the goal, which has the continuity required for 'hill
climbing', and confirming the code. So all that the feed back does is say "don't
change the code". This is completely different to 'changing the code to get to
the goal'. It's another level of indirection.  Or ?

If the path towards the goal has a discontinuity, the code and all the so far
optimistic confirmation runs must be discarded. And I don't see how
knowledge of the
wrong decision/s can be retained to be used for future.


So there's 1: the set of codes which have been tried and failed, and
there's 2: the current 'state'.  '2' is a memory but what about '1'.
Well, by Goedel the 'codes' can be ordered, and it they were executed in the
'ordered' sequence, then the automata only needs to know the current Goedel
number to know what code to try next!


So a possible algorithm could be:
FOR Goedel-code 0 till timeOut DO
  FOR EACH VAIABLE sweepTheVariable
   and use hill-climbing as far as possible to optimise the variables.

But each combination of operator and control-construct gives a new family of
variables.
This is FAR from the original idea of the 'code' hill-climbing towards
the goal !!

== Chris Glur.
I'm posting this to comp.ai.genetic to try to get some answers.