Le 19-oct.-06, à 22:57, Colin Geoffrey Hales a écrit :
> Is the UD process
> a) UD generating all programs
> then
> b) UD executes all of them
No. The UD is one program, it cannot generate all programs and *then*
begin to run them.
That would be like condemning a thief to perpetuity and then to death.
>
> or
>
> a1) The UD generate program X,
> then
> b1) launches execution of X (adds it to the heap already running) in
> itself
> c1) Go to a1
>
> Is the "1 step at a time" execution
>
> 1 processor time 'slice' =
> --------------------------
> N = 1
> a) step N in program a
> b) step N in program b
> .
> .
> Last) step N in program 'last'
> N = N+1
> Go to a)
> ----------------------------
> or
>
> --------------------------
> N = 1
> a) 1 time 'slice' = step N in program a
> b) 1 time 'slice' = step N in program b
> .
> .
> Last) 1 time 'slice' = step N in program 'last'
> N = N+1
> Go to a)
> ----------------------------
>
> Q In other words can the UD be regarded as having an operating system
> of
> some sort that navigates its way invisibly to all the programs it is
> running?
>
> Q Do you consider the UD fully operational before or after all the
> programs are generated?
>
> Q At what point does whatever serves as the 'reality' of being a UD get
> officially/fully launched?
>
> I'd like to think about a various single/multi processor
> serial/parallel
> UD implementations. I have experiences with these - real time
> industrial
> process control software is more like the UD than an multi-tasking
> operating system. 'Time' in a real-time control system is very
> different
> to that in a standard multitasking operating system. Also the
> coordination
> of programs is an issue. The software is very different....
>
> If I could get my head around the above I can calibrate my UD thoughts
> in
> these terms.
Let us fix a universal machine, for example FORTRAN.
Let P1, P2, P3, P4, ... Pi, .... be a recursive enumeration of all
Fortran programs. This gives an enumeration of all partial recursive
functions F1, F2, F3, F4, F5, F6, ... (I have already prove that such a
list cannot be composed of everywhere defined (total) functions: the
list of the Fi has to own partial functions, placed in a necessarily
non computable way among the Fi. Put in another way, there is no
mechanical way to filter the always terminating programs in the list of
the Pi. This is why the universal dovetailer has to dovetail.
How does the UD proceed. It is not easy to describe this without
formulas and/or drawing, but the idea can be described by showing what
it does at the beginning of its work. To simplify I suppose the Pi
being 0-argument program (and I let you explain why this can be done
for multiple argument programs; ask if you don't succed; it need just
one more level of dovetailing).
The UD generates P1, then execute one "time step" of its execution,
then it generates P2 and executes one step of P2, then come back to P1
and executes one step more of P1, then one step of P2, then it
generates P3. Then it executes one step of P3, and come back to P2 (one
step more of execution) and then come back to P1 (one step more
execution), then P2 (one step more) then P1 (one step more (osm)) then
P2 (osm) then P3 (osm) then it generates P4, and execute the first step
of P4. Then come back on P3 (osm) P2 (osm), then P1 (osm), then,
continuing its zigzagging P2 (osm), P3 (osm), P4 (osm) and then
generate P5, and execute P5's first step. Then (no more mentionning the
osm), P4, P3, P2, P1, P1, P2, P3, P4, P5, P6, P5, P4, P3, P2, P1, P2,
P3, P4, P5, P6, P7, P1, P2, P3, P4, P5, P6, P7, P8, P7, etc.
This dovetailing (zigzagging) has to be done for being sure not to be
stuck in some non terminating programs.
The precise notion of "one step of execution" can be given by the
primitive operation of the language/universal machine used. here, with
Fortran, it can be defined by a one primitive instruction line (simple
assignment, elementary reading of register, elementary writing of a
register, etc.).
I hope this answer your question, but ask for precisions if needed.
Try, as an exercise, to write the longer running of a dovetailer of
programs with one variable (inputs). You have to imbricate the
dovetailing on all inputs.
Bruno
http://iridia.ulb.ac.be/~marchal/
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Everything List" group.
To post to this group, send email to everything-list.domain.name.hidden
To unsubscribe from this group, send email to everything-list-unsubscribe.domain.name.hidden
For more options, visit this group at
http://groups.google.com/group/everything-list
-~----------~----~----~----~------~----~------~--~---
Received on Fri Oct 20 2006 - 06:26:02 PDT