resolving Will's misunderstanding

From: |-|erc (gotchy_at_beauty.com)
Date: 05/18/04 

Date: Tue, 18 May 2004 00:45:32 GMT

WILLS 1st POST

>>it's input (recurse as desired), so the whole thing is silly. It would
>>be like writing a Windows emulator and running it on Windows instead of
>>Mac/Linux.
>>
>
>
> Exactly, but how else are you going to perform Barbs modified diagonal function?
> G(j) = UTM(j,j) mod 2 + 1,

Huh? G(j) is UTM modified. You don't even need the Godel number of UTM
to encode it, just modify UTM to read in j, replicate it, run UTM on it
(which results in UTM(j,j) ), then mod it and add 1.

*************** #1 **************

> Assuming UTM is only total functions.

Here's the problem. You are *adding* an assumption.

> Also, assemble and compile mean the same thing, its not machine language, particularly
> when it uses labels assembly is just compiled. You can't ASSUME a language in a
> proof of contradiction, you have to show all possible languages will result in the
> contradiction. Raw TMs don't have labels accessible outside of that single function,
> its a set of states not a list.

If the proof works in a language that is equivalent to the instructions
on a TM, it will work for ALL languages that are equivalent to the
instructions on a TM. There may be some languages that would generate a
contradiction, but that indicates a limitation on the language, not the
proof.

************ #2 **************

WILLS 2nd POST

> you have some proof otherwise. The only rebuttal was diagonalisation over the
> set, which is invalid considering diagonalisation will only work on a function
> calling paradigm of algorithms, not more elementary systems.

Where did you get this idea? The diagonalization argument works with
any method of uniquely identifying a function. Godel numbering comes to
mind. Then you *emulate* the function based on its number.

****************** #3 ******************

> You've all tossed away WHAT functions do, and are entrenched with your
> theory about WHO the functions are, giving them names and twisting them.

The halting problem has no reference to functions. Functions are
irrelevent to the problem. Try talking about the halting problem
without using the word "function", it may help you see what we are
talking about. There are only machines with an input and an output.

******************* #4 ******************

>
> My theory is so trivially simple, I don't see how 1,000 so called computer maths
> theorists here are so blind about it.

This statement should be a clue to you.

> TMS dont have names, you can't link one state in one TM to another state in
> another TM and say THIS TM CALLED THAT TM. YOU CANT DO THAT!

We never said you did. However, you can think of the Godel number of a
TM as its name, and you can tell a TM to emulate another TM's
processing. I don't know why you don't understand this.

===========================================

#1

Here Will is saying to make the 'broken' function we modify the existing UTM.
I've posted the proof that this is not a valid modification several times now.

#2

Will says :
If the proof works in a language that is equivalent to the instructions
on a TM, it will work for ALL languages that are equivalent to the
instructions on a TM

This is like saying, every contradiction has an analogy in every language. This
is clearly wrong. In functional programming there are many subtle paradoxes
of reference due the to consise expressive power of the language. As languages
get more primitive, the amount of code to perform the same calculation is much larger.
Will seems to think that because a TM has a reference, its godel number that the
UTM can emulate it with, that functions can call one another in a nested fashion exactly
like Pascal. Say TM-333 adds 2 to its argument. Say TM-444 outputs number 7.

Does
UTM
0000000000033300000444

output 9? No it doesn't. Only the UTM can emulate the function, functions can't
call one another.

Making up a contradiction using G = lamba x (mod(F(x, x))) is NOT POSSIBLE
with a TM. It might be possible depending how easy F is to modify, but its
not always possible, F might be defined as mod2(G(x)), G is not free in F.
Do these situations arise with RAW TMs? Not at all.

#3

Will says :
The diagonalization argument works with
any method of uniquely identifying a function. Godel numbering comes to
mind. Then you *emulate* the function based on its number.

This comes just after saying #1,
G(j) is UTM modified. You don't even need the Godel number of UTM
to encode it, just modify UTM to read in j, replicate it, run UTM on it
(which results in UTM(j,j) ), then mod it and add 1.

So which is it Will? Can you stick to some method of accessing a function
and derive results based on that one method?

#4 Rebuttal

Will says :
Functions are irrelevent to the problem. ... There are only machines with an input and an output.

Try looking up a defn of a function.

Herc 

--
 \          oo
   \____|\mn
    / /_/ /\ \_\      - FREE THE TRUeMAN -
  / K-9/  \/_/       - Join www.chatty.net -
/____/_____\     - Webmasters join www.BannerX.net -
Quantcast