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@googlegroups.com To unsubscribe from this group, send email to [EMAIL PROTECTED] For more options, visit this group at http://groups.google.com/group/everything-list -~----------~----~----~----~------~----~------~--~---