Hi Günther,

On 01 Jan 2009, at 23:58, Günther Greindl wrote:

> Bruno,
> I have also wanted to ask how you come to 2^aleph_zero
>> Well, in part this results from the unbounded dumbness of the
>> universal doevtailing procedure which dovetails on all programs but
>> also on all non interacting collection of programs (as all  
>> interacting
>> one).
> How do you discern interacting/non-interacting programs? What do you
> mean exactly with the term in regard to UD?

To write and implement a Universal Dovetailer, you have to fix a  
universal programming language (or machine). Then the UD will generate  
the list of programs P_1, P_2, P_3, ... and run them by little pieces,  
let us say of one running step, and this for each program in such a  
way that it dovetails on all the executions, including those who does  
not stop, which we cannot avoid.

Let us assume tthat the sequence P_1, P_2, P_3, ... P_i  ...   is the  
sequence of the zero variable programs (this changes nothing). Now a  
computation, for example, the computation of P_0,  will itself be a  
sequence of computational steps, like

P_1^1, P_1^2, P_1^3, etc ...

To run the UD, we dovetail or zig zag on the programs and their  
computational steps. Exercise: add some relevant zig zagging to the  
following infinite diagram:

P_1^1, P_1^2, P_1^3, P_1^4, ...
P_2^1, P_2^2, P_2^3, P_2^4, ...
P_3^1, P_3^2, P_3^3, P_3^4, ...
P_4^1, P_4^2, P_4^3, P_4^4, ...

A solution: P_1^1, P_1^2, P_2^1, P_3^1, P_2^2, P_1^3, P_1^4, P_2^3,  
P_3^2, P_4^1, ...

Each computational step P_i^j, of the ith program up to the jth step  
is completely independent of any other computations P_k^h, when i is  
different from k. Such computations do not interact. The DU, if  
programmed correctly, will never let them share the memories or  
interact in any way.

But for each couple (P_i, P_k) there is another program, P_h in the  
(infinite but enumerable) list P_i which is a mini-dovetailer of the  
pair of programs (P_i, P_k). This means P_h dovetails itself on the  
execution of the two programs P_i and P_k.  Indeed, trivially, the  
universal dovetailer execute all the possible dovetailing, the  
universal one and all the other one.

Again, the two new computations of P_i and P_k does not interact.

But that is not enough, for all couple of programs (P_i, P_k) there is  
third program P_g, which you can seen as a bad or buggy dovetailer on  
the pair (P_i, P_k), which will execute P_i and P_k again, but with  
just one shared memory, so that progress in the running of one of them  
will destroy the memory of the other. In that sense the buggy mini- 
dovetailer makes P_i and P_k interact, in one way.

Given that any digital interaction process, it can be simulated by a  
program, and the UD will soon or later simulate that interaction.

For another example, the UD will run all patterns of the game of life,  
but also all couple of such patterns, all triples, all quadruples,  
actually all finite pieces of possible "Eden garden" of possible  
cellular automata.

You can actually imagine any ways of making two programs or machines  
interact, soon or later the UD will generate ONE computation which  
will run the interaction of those machines, yet such computation will  
not interact with the proper other UD-computations. The UD will even  
generate a universal buggy dovetailing computation which makes all  
programs interact with each other, in all possible ways. All right?

Please ask if something is not clear. It is simpler to explain all  
this with conical drawings, and the internal zig zagging.

>> In particular each computation is "entangled" to dovetailing on
>> the reals,
> What do you mean by this? How do the reals enter the picture?

Do you remember the iterated self-duplication experiment? Suppose I  
invite you to make that experience. But your boss asked you to do some  
computation P (and thus your computation looks like P^1, P^2, etc...  
(the number = the steps of your computation).
So, you will do your computation and simultaneously do the iterated  
self-duplication. To simplify I will assume that you do one step of  
your computation at each duplication.
I duplicate you iteratively in two rooms, one with the number zero  
written on the wall, the other with the number one on the wall. OK?
And during that time you make the computation (to please your boss).  
So you compute P, get the first step of the computation: P^1, go to my  
duplicator (where you are scanned---and this includes your "step  
result" P^1----annihilated, and reconstituted in the zero-room and in  
the one-room. The two of you come back, each one of you compute one  
step of the computation to get P^2, and enter the duplicator again.  
Both are scanned, including the P^2 step-result, and then annihilated  
and reconstituted again in the two rooms. The four of you come back,  
compute the third step of the computation, and enter again the  
annihilator ...., the eight of you come back, compute the fourth step  
of the computation, and enter the duplication again, ..... the 2^n of  
you come back, compute the nth step of the computation, and enter  
again in the duplicator, etc.

Now imagine your boss was a bad guy wanting to annoy you so that your  
computation is infinite: he gives to you an infinite task. And, you  
are not very lucky that day, because for my scientific research, I ask  
you to iterate an infinite numbers of times the self-duplication  

In that case, I will say that I, with your kind help, have entangled  
the infinite computation (the one that was asked by your boss) to the  

The infinite self-duplication generates the reals (all the reals, and  
this without naming them nor enumerating them: no contradiction with  
Cantor theorem). The *you* can remember their path in the rooms. A  
typical one will be, after 26 self-duplications:


and the "you" here will have computed 26 steps of the boss  
computation, ready to compute the 27th steps and enter the duplicator  
You see that on each real number (well, between 0 and 1 like  
0,11011101000011010011000101 ...), the construction duplicates your  
boss computation on each decimal. There are 2^aleph_zero reals, so in  
the limit, your infinite computation get multiplied by 2^aleph_zero.

Now all this was a computable process. The boss gave you a  
computation, and the self-duplication procedure and unlimited  
iteration is programmable. So such process is executed, soon or later  
(well, really later!) by the UD, and this is true whatever computation  
your boss decided to give to you, of course. So you see that the UD  
entangles all computation with the real as possible oracles (like if  
you decide to use the room data (0 or 1) in your computation. It is  
again a case of interaction/non interaction. The UD realizes all  

Those real generations never appears in the execution of the UD, as  
seen in a third person point of view where everything is countable,  
but they could and actually have to play a role from the point of view  
of the self-referential betting entities relatively generated by the  
UD computations. This come from the fact that the first person is not  
aware of the delays of reconstitution, so that the measure, which bear  
on the computations, is somehow defined in the limit (cf the steps 2  
and 4 of UDA).

This is our fatal destiny of universal machine: our consciousness  
lives in the terrestrial neighborhood of zero (the realm of the  
finite), but the measure which differentiates our stable and solid  
histories is defined in the celestial neighborhood of the infinite!

Tell me if this helps,



You received this message because you are subscribed to the Google Groups 
"Everything List" group.
To post to this group, send email to everything-l...@googlegroups.com
To unsubscribe from this group, send email to 
For more options, visit this group at 

Reply via email to