On 3/11/2024 1:49 PM, Richard Damon wrote:
On 3/11/24 7:25 AM, olcott wrote:
On 3/11/2024 1:17 AM, Richard Damon wrote:
On 3/10/24 10:40 PM, olcott wrote:
On 3/11/2024 12:07 AM, Richard Damon wrote:
On 3/10/24 9:33 PM, olcott wrote:
On 3/10/2024 10:07 PM, Richard Damon wrote:
On 3/10/24 7:47 PM, olcott wrote:
On 3/10/2024 9:08 PM, Richard Damon wrote:
On 3/10/24 5:32 PM, olcott wrote:
On 3/10/2024 2:16 PM, immibis wrote:
On 10/03/24 19:32, olcott wrote:
On 3/10/2024 1:08 PM, immibis wrote:
On 10/03/24 18:17, olcott wrote:
ZFC simply tossed out the Russell's Paradox question as unsound.
>
So you are saying that some Turing machines are not sound?
>
Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
(a) Their input halts H.qy
(b) Their input fails to halt or has a pathological
relationship to itself H.qn.
>
But the "Pathological Relationship" is ALLOWED.
>
ZFC simply tossed out the Russell's Paradox question as unsound
expressly disallowing the "Pathological Relationship".
>
So you are saying that some Turing machines are not real Turing machines?
>
I am only claiming that both H and Ĥ.H correctly say YES
when their input halts and correctly say NOT YES otherwise.
>
well the halting problem requires them to correctly say NO, so you haven't solved it
>
All decision problem instances of program/input such that both
yes and no are the wrong answer toss out the input as invalid.
>
I noticed that you gave up on Olcott machines and now you are back to your old bullshit ways of pretending that the same machine can produce two different execution traces on the same input. Why don't you show us an execution trace where that happens? Both traces must show the first instruction that is different in both traces and I recommend showing 20 more instructions after that, but you can abort one after that time, if it doesn't halt, to prevent the trace getting infinitely long.
>
Turing Machines and Olcott machines cannot properly implement
H1(D,D) and H(D,D) that know their own machine address.
>
My C code proves these two have different behavior:
(a) H1(D,D) + H1_machine_address
(b) H(D,D) + H_machine_address
>
Because they are different computations they are
not required to have the same behavior.
>
Right, but it also means that since the dfference is because of a "Hidden" input none of them qualify as a Halt Decider.
>
>
The key input (the machines own address) is not hidden
merely unavailable to Turing machine and Olcott machines.
>
And if it isn't hidden, then the other copies that take use a different address become different computations and can't claim to fill in for THE H.
>
You then prove each copy wrong by giving it the version of H^/D that is built on it, which it will get wrong.
>
All the other ones might get it right, showing that there IS a correct answer.
>
>
>
H(D,D) immediately sees the first time it calls itself
with its same inputs.
>
H1(D,D) never sees it call itself with its same inputs.
>
Full Execution trace of H1(D,D)
(a) main() invokes H1(D,D)
(b) H1(D,D) simulates D(D)
(c) Simulated D(D) calls simulated H(D,D)
(d) Simulated H(D,D) simulates another D(D)
(e) Simulated H(D,D) aborts this D(D) when it would call itself
(f) Simulated H(D,D) returns 0 to simulated caller D(D)
(g) Simulated caller D(D) returns to H1(D,D)
(h) H1(D,D) returns 1 to main()
>
They cannot be implemented as Turing Machines or Olcott
Machines. They can be implemented as RASP machines proven
by the fact that they are implemented as C functions.
>
>
Right, which proves your C functions also were never the required computation, as they has an extra "hidden" input. As has been told to you many times in the past.
>
When I specify that every machine can know its own machine address
in x86 machines and (possibly augmented) RASP machines then it is
not hidden and an explicitly part of the input to the computation.
>
And if it isn't hidden, then the other copies that take use a different address become different computations and can't claim to fill in for THE H.
>
You then prove each copy wrong by giving it the version of H^/D that is built on it, which it will get wrong.
>
All the other ones might get it right, showing that there IS a correct answer.
>
>
>
So, you just admitted that you hae just been lying for all these years, and you are no closer to your fantasy goal then you ever were.
>
Sorry, you just don't know enough to do this problem.
>
I just admitted that it took me about two years to translate my
intuitions into words that address your objections.
>
For these two years you and many other people claimed that H1(D,D)
could not possibly do what it actually did actually do. This has
always been the same thing as disagreeing with arithmetic.
>
>
It can't do it and be the SAME COMPUTATION as H, which is what you were claiming.
>
>
It did actually do exactly what I claimed and everyone wanted
to stick to their opinion and deny the actual facts that it
did actually do what I said.
>
It might have done what you THOUGHT you were saying, but it doesn't do what you ACTUALLY SAID.
>
>
I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
always said it was impossible even though that is what actual code
actually did. The code always discloses that H and H1 have their own address.
>
No, we said it was impossible if they were the COMPUTATIONS you were claiming them to be.
>
>
I never ever claimed that they were the same computation.
yes you did. You problem don't remember because the word computation doesn't seem to have a real meaning to you.
I have known the meaning of theory of computation meaning of computation
for two years. It was very difficult to correctly adapt this to account
for C functions. I finally did and had it checked over by quite a few
people and for C functions to be computable functions they must be this
notion of a pure function.
https://en.wikipedia.org/wiki/Pure_function>
That was expalined, and you ignored it, so it wasn't an "Honest Mistake", but a willful disreguard for the truth, and thus a LIE.
>
You never ever bothered to look at the code proving that it was correct.
Nope, looking at the code proves your statement that H1 is a standing compuation for H is proved incorrect.
I cannot unravel what your words mean.
Your claim that H1 shows that it getting the right answer shows that the algorithm of H gets the right answer implies that H1 and H are the same computation, and thus that you are lying, or totally ignorant.
That is ridiculous because I have always claimed that
H1(D,D)==1 and H(D,D)==0 are both correct.
H1 and H have the exact same input and essentially identical code.
The fact that you continued after your error being pointed out, says it is no longer just an honest mistake, but a blatant lie.
You kept saying that the results that H1(D,D)==1 and H(D,D)==0
were getting they cannot possibly get.
That is the same as saying: "I think therefore thinking does not exist."
<snip>
You never ever bothered to look at the code proving that it was correct.
How can it be. The code of H says that the H^ built from it will be non-halting when it is in fact Halting.
We are not talking about that. We switched to H1(D,D)==1 and H(D,D)==0.
It is obvious that these return values are correct from the one page
execution traces of main(), D simulated by H1, D simulated by H. That
you and everyone else denied verified facts was very annoying.
That a Halting Machine can be correct decider to be non-halting is just a lie.
When simulating terminations analyzers answer this question:
Will you halt if you never abort your simulation?
They cannot be contradicted.
When they answer this question:
Does your input halt when it is directly executed?
They can be contradicted.
No one ever said that a DIFFERENT decider couldn't get the right answer, so if H1 is a DIFFERENT decider, it doesn't prove anything,
For two years you claimed that it was wrong without
ever bothering to look at the proof that it was correct.
Your claims that H1 is just the same decider, is proven to be a LIE
H1 has the exact same input as H and is essentially
identical to H1. The key difference is that it is
at a different memory address.The other differences
are an artifact of the x86 language and have no effect.
A lie because your decider algorthm H NEVER to just the inputs of the machine and input, but also the address of the decider as a HIDDEN INPUT (hidden and thus a lie)
It didn't occur to me until recently that the fact that
each function knows its own machine address and uses it
in its computation should be construed as a theory of
computation input to its computable function.
None-the-less the execution trace of:
(a) main()
(b) D simulated by H1
(c) D simulated by H
always did prove that H1(D,D)==1 and H(D,D)==0 are correct.
If you ever bothered to look at the proof that H1(D,D)==1
and H(D,D)==0 are correct this would have been resolved
two years ago.
-- Copyright 2024 Olcott "Talent hits a target no one else can hit; Geniushits a target no one else can see." Arthur Schopenhauer
Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior