XPost: comp.theory, sci.logic, sci.math
On 11/7/2021 6:39 PM, André G. Isaak wrote:
On 2021-11-07 17:25, olcott wrote:
On 11/7/2021 3:59 PM, Mr Flibble wrote:
On Sun, 07 Nov 2021 20:52:58 +0000
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
Mr Flibble <flibble@reddwarf.jmc> writes:
On Sun, 07 Nov 2021 13:57:26 +0000
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
olcott <NoOne@NoWhere.com> writes:
After many reviews no one has pointed out any error in this
claim: There is no possible simulating halt decider H such that
the correct pure simulation of the input to H(P,P) ever reaches
the final instruction of P.
As you know, there are no halt deciders
Not true. As long as the decider can recognize pathological self
reference and has infinite resources it can decide if a program
halts.
That's not what a halt decider is.
Sure it is.
/Flibble
...As long as the decider can... decide if a program halts:
Then we know it must be a halt decider for this program.
Because they are so highly motivated to disagree here are the key
points that no one else yet understands:
(A) If the simulated input of H(P,P) never halts then it is correct
for H to report that its simulated input never halts.
Not when you claim that the simulation can differ from the actual
execution.
So you are saying that sometimes a cat is not a cat.
Arguing with semantic tautologies makes you look stupid.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Putting aside your strange use of the term 'simulate', a halt decider
So again you are saying that a cat is not a cat except that you are
saying that a correct simulation is not a correct simulation.
When each instruction of the x86 source code of P is simulated in the
exact same sequence that it is specified in the above source code then
we know that this aspect of the pure simulation the input to H(P,P) is perfectly correct.
We also know that when H is a pure simulator of its input that the
seventh line of the correct pure simulation execution trace shown below
would result in another identical sequence of seven lines.
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [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)
must accurately describe the behaviour of "executed P". That's the
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
(B) Because of the one-way dependency relationship between the
executed P and the simulation of itself that it invokes: H(P,P)
[ P only halts because H(P,P) returns 0 ]
the executed P has different behavior than its simulated P.
Because there is no such dependency relationship in H1(P,P) the pure
simulation of its input corresponds to the direct execution of this same
input.
--
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)