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.



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@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 

Reply via email to