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
experiment.
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
reals.
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:
11011101000011010011000101
and the "you" here will have computed 26 steps of the boss
computation, ready to compute the 27th steps and enter the duplicator
again.
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
options.
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,
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?hl=en
-~----------~----~----~----~------~----~------~--~---
Received on Fri Jan 02 2009 - 11:15:40 PST