XPost: comp.theory, sci.logic, sci.math
On 10/31/2021 12:46 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 10/31/2021 10:11 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
The only other possibility is that H is a halt
decider that aborts its simulation of P at the
machine address 0xc41 of P. In this case P also
never reaches is final state at machine address
0xc50. Thus in every possibility P never reaches
its final state and thus never halts.
So having lost the argument in relation to Turing machines, you have
returned to your hidden code that gets the wrong answer?
(1) I haven't lost the argument on Turing Machines.
(2) I conclusively prove that the input to H(P,P) never halts in
Message-ID: <hIednR1p-IK1NuP8nZ2dnUU7-ePNnZ2d@giganews.com>
Giganews posted this message to other groups and skipped itself.
The input to H represents the computation P(P). At least up until
recently you asserted that P(P) halts and you spent a lot of time trying
to hand-wave away the wrong answer from H.
Or do you now
accept that H(P,P) == false is wrong if P(P) halts? To get any traction >>> you really do have to admit that defining the wrong answer to be the
right one simply did not cut it!
By playing tricks (which will remain as hidden as your code) you can
arrange for H(P,P) == true when P(P) halts which would be a welcome
change of heart.
There are no tricks.
Good. That means you can't have H(P,P) == true iff P(P) halts.
There are only two possible cases:
(1) H(P,P) aborts its simulation and P never reaches its final state
at 0xc50
(2) H(P,P) does not abort its simulation and P never reaches its final
state at 0xc50
Therefore when H(P,P) decides that its input never halts H is
necessarily correct.
I can see you don't want to answer.
I have answered, perhaps you are not smart enough to understand the answer?
I was asking if you have changed
your mind,
If in both possible cases where H(P,P) aborts the simulation of its
input or H(P,P) fails to abort the simulation of its input P never
reaches its final state at its own machine address of 0xc50 then we know
that P never reaches this final state.
Smart people that understand the x86 language know that when H is a pure simulator that P does specify infinitely nested simulation at its
machine address 0xc41. Even Richard understands this part.
Smart people that understand the x86 language know that when H aborts
its simulation of P at the machine address of 0xc41 of P that the input
to H(P,P) never reaches its final state of 0xc50.
This means that the following code provides proof that the input to
H(P,P) never reaches its final state of 0xc50 in any possible case, thus
the input to H(P,P) never halts.
The following is taken from pages 4 and 5 of this paper:
Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}
_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]
_main()
[00000c56](01) 55 push ebp
[00000c57](02) 8bec mov ebp,esp
[00000c59](05) 68360c0000 push 00000c36 // push P
[00000c5e](05) 68360c0000 push 00000c36 // push P
[00000c63](05) e8fefcffff call 00000966 // call H(P,P)
[00000c68](03) 83c408 add esp,+08
[00000c6b](01) 50 push eax
[00000c6c](05) 6857030000 push 00000357
[00000c71](05) e810f7ffff call 00000386
[00000c76](03) 83c408 add esp,+08
[00000c79](02) 33c0 xor eax,eax
[00000c7b](01) 5d pop ebp
[00000c7c](01) c3 ret
Size in bytes:(0039) [00000c7c]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00000c56][0010172a][00000000] 55 push ebp [00000c57][0010172a][00000000] 8bec mov ebp,esp [00000c59][00101726][00000c36] 68360c0000 push 00000c36 // push P [00000c5e][00101722][00000c36] 68360c0000 push 00000c36 // push P [00000c63][0010171e][00000c68] e8fefcffff call 00000966 // call H(P,P)
Begin Local Halt Decider Simulation at Machine Address:c36 [00000c36][002117ca][002117ce] 55 push ebp [00000c37][002117ca][002117ce] 8bec mov ebp,esp [00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08] [00000c3c][002117c6][00000c36] 50 push eax // push P [00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08] [00000c40][002117c2][00000c36] 51 push ecx // push P [00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)
[00000c36][0025c1f2][0025c1f6] 55 push ebp [00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp [00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08] [00000c3c][0025c1ee][00000c36] 50 push eax // push P [00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08] [00000c40][0025c1ea][00000c36] 51 push ecx // push P [00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
and I know that's very hard for someone in your position to
admit. Here's the key question: do you still assert that H(P,P) ==
false is the "correct" answer even though P(P) halts?
Yes that is the correct answer even though P(P) halts.
The fact that in all possible cases the input to H(P,P) never halts conclusively proves that H(P,P)==0 is correct no matter what.
H1(P,P)==1 is consistent with the behavior of P(P).
The difference between H(P,P) and H1(P,P) is that the former has
pathological self-reference and the latter does not. This makes these
two computations distinct from each other and thus not equivalent.
If you won't say,
nothing you do say about what is "correct" (necessarily or otherwise) is pointless.
Of course, it's likely you have no changed you mind and you are still searching for words to make the wrong answer seems less obviously
wrong. Not answering my question is a key part of that strategy so I
don't expect an answer.
Pathological self-reference has been my life's work. For other people
where this is not the case it would be much more difficult to
understand. The fact that H reports a halt status that is consistent
with the behavior of its input conclusively proves that H is correct.
The input to H1(P,P) has behavior that is computationally equivalent to
P(P).
The input to H(P,P) does not have behavior that is computationally
equivalent to P(P).
The difference in behavior is caused by pathological self-reference.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)