Let me correct one little issue which I think helps to clarify what I am 
saying.  I add a  comment on the universal dove-tailer.

1) Yesterday I said that the cascade 1+1=2, 2+1=3, 3+1=4, etc. was not 
everywhere elegant.  But I went outside my identification process for 
"determinism" = "everywhere elegant proof" to do so. The error was to slip 
into full number theory and think: "84" one of the strings this cascade 
will eventually reach for example has more than one proof. That is true 
because number theory is richer than just "data + 1 =".

But here the working definition of "deterministic" I use is that all of the 
selected set of rules of a cascade act at each step on all the data. You 
should not have within the idea of "deterministic" some of the rules active 
today and some others active tomorrow, some of the data regions exempt from 
some rules today and other data regions partially exempt tomorrow unless 
that was itself in Rj.

Deterministic as I understand it = all the rules of physics always apply to 
the entire state of the universe.

So for the above cascade we have selected "data + 1 =" as the exclusive 
expression - the entire rule set of the operative FAS - for which we are 
seeking the cascade of values given some start data [effectively the axiom 
of that cascade] in this case "1".

The fact that this rule may also belong to a different and richer FAS is 
not germane to the cascade viewed as an attempted deterministic sequence. 
The operative FAS contains just this one rule as its Rj and applies it to 
all the data at each step. That makes this cascade everywhere elegant 
because there is no other proof of any of the output strings available in 
the operative FAS.  Thus hits the complexity wall established by the 
complexity of the operative FAS.

2) A universal dove-tailer generating all strings using a fixed algorithm 
every part of which applies to all the current data in the same way at each 
step seems an odd thing.

A dove-tailer is not directly generating the "whole" ensemble.  What it is 
doing is selecting by fixed rules a particular string out of the ensemble 
and adding some quantity of bits, putting that back in and selecting 
another and adding some quantity of bits to it etc., etc. That is a very 
selective and complex process on a step by step basis.   You wind up 
constructing this incredibly complex everywhere elegant proof of what must 
then be an incredibly complex object that is nevertheless considered to be 
a very low complexity object.

If I have the ideas of a UD, elegant proof, and AIT complexity correct the 
UD appears to be a contradiction.

The contradiction again is that we have a FAS that constructs a proof it 
knows is elegant that is nevertheless far more complex than any proof it 
can know is elegant.


Reply via email to