🚀 go-pugleaf

On Jan 5, 8:19 pm, Graham Cooper <grahamcoop...@gmail.com> wrote:
> RE: COMPUTING CHAITIN'S OMEGA
>
> You haven't lived until you've zoomed inside a Mandelbrot and found a
> smaller? Mandelbrot on it's side!
>
> http://www.fractint.org/http://blogs.gnome.org/jamesh/files/2011/03/mandelbrot.jpeg
>
> There are "countless" Mandelbrots inside the Mandelbrot itself, so of
> course zooming into one again will lead to smaller still Mandelbrots
> at recursively lower and lower levels, taking up smaller and smaller
> infinitesimal segments of the complex number Argand Plane.
>
> (0.33300003, 0.6611238) - (0.33300004, 0.6611239)
> If there's a small MandelBrot there that was a lucky guess!
>
> As a metaphor, think of each Mandelbrot as the Computable Numbers, but
> the rotation and skew of the sub Mandelbrot results in a slightly
> different rendering, of the same SET of computable numbers in a
> different presentation / permutation / ordering!
>
> -------
>
> First, with so many counter-examples to enumeration of all functions,
> we need some hard evidence of countable 2^N.
>
> A Universal Turing Machine is just a special type of computer program,
> or Turing Machine.
>
> Instead of inputting 1 number and outputting another number, it inputs
> a mashed together pair of numbers #1 & #2 and outputs the result of
>
> TM#1(#2) --> OUTPUT  (of TMn starting with the value of #2 on it's
> Tape)
>
> <=> UTM(TM#, INPUT) --> OUTPUT  (emulated TM#1)
> <=> UTM(#1, #2) --> OUTPUT
>
> =TMxxxxxx (#1mashed#2)  (hardware computed)
>
> So every Trillion, Trillion, Trillion.. Trillion or so Turing Machines
> if you enumerate them all, you come across a Universal Turing Machine.
>
> It's not difficult to manually program a UTM either, like the EVAL()
> function in LISP will input any LISP program and emulate it and give
> the output.  But if it took 5,000 bytes to program the smallest
> possible Eval function, then that file size is equivalent to it's
> GODEL NUMBER NUMBER-SIZE of a UTM or the ENUMERATION NUMBER of it's TM
> number.  i.e. the Trillion .. Trillion Trillionth Turing Machine is a
> UTM, with each 1 Trillion possibilities taking up 40 bits so 5KB would
> be
>
> TRILLION, TRILLION, ... 1000TIMES ... TRILLION TURING MACHINES
>
> until you hit a Universal Turing Machine!
>
> In Emperor's New Mind there is a 20 page binary listing of the
> smallest UTM using standard TM format, which was actually 8 bits
> longer than it had to be!
>
> --------
>
> Moving right along... HOW TO COMPUTE CHAITIN'S OMEGA
>
> If you can't compute HALT(TM#(0)) for any arbitrary TM#
>
> you can't compute 0 . TM1(0) TM2(0) TM3(0) TM4(0) ...
>
> which is a bona fide real number!
>
> Since every TM must either HALT or LOOP that is, and the future should
> be extractable on some meta-theoretical level if not a computable one!
>
> So this is the output of the table UTM(TM#, INPUT)
>
> TM# - INPUT ---->
> ------- 1 2 3 4 5 6 7 ...
> 1  ---- 0 0 0 0 0 0 0 ...
> 2  ---- 1 1 1 1 0 0 1 ...
> 3  ---- 0 1 1 1 0 0 0 ...
> 4  ---- 0 0 0 0 0 0 0 ...
> 5  ---- 1 1 B 1 B 1 1 ...
> 6  ---- 0 0 0 0 0 0 0 ...
> ...
>
> Some of the values are BLANK, for "STILL COMPUTING" since we can't
> determine the complexity of tabulating the computable numbers.
>
> We output 0s and 1s only, as it's equivalent to outputting Naturals.
>
> IF HALT exists, then you could compute the values of all TM#(0) which
> halted, and output
>
> 0 IFF TMn(0) loops
> 0 IFF TMn(0)=1   //go ahead and compute it
> 1 IFF TMn(0)=0   //go ahead and compute it
>
> which will compute a real number roughly defined as
>
> 0 . !TM1(0) !TM2(0) !TM3(0) ...
>
> Omega is a bit more complicated but could be calculated using this
> "non-computable" number.
>
> This is non-computable because it's the ANTI-DIAGONAL of the UTM
> Table.
>
> TM# - INPUT ---->
> ------- 1 2 3 4 5 6 7 ...
> 1  ---- [0] 0 0 0 0 0 0 ...
> 2  ---- 1 [1] 1 1 0 0 1 ...
> 3  ---- 0 1 [1] 1 0 0 0 ...
> 4  ---- 0 0 0 [0] 0 0 0 ...
> 5  ---- 1 1 B 1 [B] 1 1 ...
> 6  ---- 0 0 0 0 0 [0] 0 ...
> ...
>
> NON-COMPUTABLE = 0.100101...
>
> assuming B is an infinite loop or finally equates to 1
> gives value 0.
>
> It's non-computable for a higher level reason than B existing, the
> Anti-Diagonal cannot equal any row so no TM# can compute the real
> 0.100101...  Let's call this real AntiDiagComputableSet or ADCS and
> note it is equally computable or uncomputable as Chaitin's Constant.
>
> -------
>
> BUT:  that was just the FIRST UTM we could find!
>
> Remember a UTM is just a Turing Machine and there is an infinite
> countable supply of TMs!
>
> Now, just like the Mandelbrots are all equivalent though slightly
> skewed from the original, all of the UTM's compute the SAME SET OF
> COMPUTABLE NUMBERS - IN A DIFFERENT ORDER!
>
> So, THERE ARE INFINITELY MANY LISTS OF COMPUTABLE NUMBERS
>
> you can count them via UTM1, UTM2, UTM3, UTM4, UTM5...
>
> which can all be indexed from 1 single parent UTM, or hardware
> computed with different UTM executable program files.  >5kb!
>
> Now CHAITINS CONSTANT can be rewritten as a FUNCTION of which
> particular UTM it represents.
>
> It's provable that
>
> EXIST(n,t)  UTMn(t,i) = CHAITINSCONSTANT(UTM1)_i
>
> i.e. You CAN compute the value of ADCS (and CC) using some other UTMn
>
> But surely that's not possible you say!  If you can compute a real and
> extract the infinite list of which programs halt or not you could use
> that string in a Halt function, it would refute the Halting Proof!
> IMPOSSIBLE!
>
> It is possible because YOU DON'T KNOW WHICH PARTICULAR UTMn contains
> the halting values of UTM1.
>
> EXIST(n) DIAGONAL(UTMn) = ANTIDIAGONAL(UTM1)
>
> -------
>
> PROOF:
>
> SINCE THERE ARE INFINITELY MANY PERMUTATIONS OF THE COMPUTABLE NUMBERS
> using any UTMs subset of UTMs that satisfy all CLA
>
> ------------------COMPLETE LIST ASSUMPTIONS-------------------
> There are 3 Properties of any List that should all hold before
> being considered as potentially complete.
>
> CLA1 = A(n): E(m): Rm = ANTI (Rn)
>
> CLA2 = A(p): A(d) d e {0,1,2..9}: E(i): Ri_p = d
>      & A(p): A(n): E(m) m>n: A(d) (Rn_p = d) -> (Rm_p = d)
>
> CLA3 = A(n): A(d1): A(d2): ... A(dn) d1..dn e {0,1,2..9}:
>        E(i): Ri_1=d1 & Ri_2=d2 ... Ri_n=dn
>
> Consider any List L of reals R1, R2, R3...
> where Ln is a permutation of L
>
> CLA1 -> A(i): DIAGONAL(L) =/= Ri  #1
>
> CLA2 + #1 -> E(L2): DIAGONAL(L2) = ANTI(DIAGONAL(L)) #2
> #2 -> A(n): E(m): ANTI(DIAGONAL(Ln)) = DIAGONAL(Lm)
>
> * for any constructed Anti-Diagonal AD
>   there is a permutation of the list with the Diagonal D = AD
>   therefore no constructed digit sequence is missing from the
>   set of possible diagonals
>
> Herc
> --http://matheology.com


idiot