XPost: sci.logic

On 7/4/24 11:30 AM, olcott wrote:

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

I don't think that is the shell game.  PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P)
*would* never stop running *unless* aborted.  He knows and accepts that
P(P) actually does stop.  The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.

It is the case that H must abort its simulation of P to prevent
its own non-termination. The directly executed P(P) benefits
from H already having aborted its simulation of P. P correctly
simulated H cannot reap this benefit proving that it is a different
sequence of configurations than the directly executed P(P).

And needed to abort is not a license to lie.

You are just proving your "Logic" is built on the concept that lies are
ok if you need to do it.

And truth doesn't acutally matter.

Thanks for telling the election and climate change deniers that their
methods are valid and it is ok to ignore the real truth.

THAT is your real message.

(I've gone back to his previous names what P is Linz's H^.)

In other words: "if the simulation were right the answer would be
right".

I don't think that's the right paraphrase.  He is saying if P were
different (built from a non-aborting H) H's answer would be the right
one.

But the simulation is not right. D actually halts.

But H determines (correctly) that D would not halt if it were not
halted.  That much is a truism.

Thus H(D,D) must abort the simulation of its input to prevent
its own non-termination.

What's wrong is to pronounce that
answer as being correct for the D that does, in fact, stop.

The directly executed D(D) is executed in a different memory
process. D correctly simulated by H is simulated in its own
separate memory process. The executed D(D) only halts because
D correctly simulated by H was aborted.

*Here is a simplified sequence*
Although the directly executed DDD() does halt, DDD correctly
emulated by pure function HHH cannot possibly reach its own
address 00002174 and halt.

*These are two different sequences of configurations*
The directly executed DDD() benefits from HHH(DDD)
having already aborted its simulation. DDD correctly
emulated by HHH cannot possibly reap this same benefit.

The call to HHH(DDD) from DDD correctly simulated
by HHH cannot possibly return. The call to HHH(DDD)
from the directly executed DDD does return.

void DDD()
{
  HHH(DDD);
}

int main()
{
  DDD();
}

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

_main()
[00002183] 55         push ebp
[00002184] 8bec       mov ebp,esp
[00002186] e8d8ffffff call 00002163
[0000218b] 33c0       xor eax,eax
[0000218d] 5d         pop ebp
[0000218e] c3         ret
Size in bytes:(0012) [0000218e]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00002183][001037cb][00000000] 55         push ebp      ; housekeeping
[00002184][001037cb][00000000] 8bec       mov ebp,esp   ; housekeeping
[00002186][001037c7][0000218b] e8d8ffffff call 00002163 ; call DDD() [00002163][001037c3][001037cb] 55         push ebp      ; housekeeping
[00002164][001037c3][001037cb] 8bec       mov ebp,esp [00002166][001037bf][00002163] 6863210000 push 00002163 ; push DDD [0000216b][001037bb][00002170] e853f4ffff call 000015c3 ; call HHH(DDD)
New slave_stack at:10386f

Begin Local Halt Decider Simulation   Execution Trace Stored at:113877 [00002163][00113867][0011386b] 55         push ebp      ; housekeeping
[00002164][00113867][0011386b] 8bec       mov ebp,esp   ; housekeeping
[00002166][00113863][00002163] 6863210000 push 00002163 ; push DDD [0000216b][0011385f][00002170] e853f4ffff call 000015c3 ; call HHH(DDD)
New slave_stack at:14e297
[00002163][0015e28f][0015e293] 55         push ebp      ; housekeeping
[00002164][0015e28f][0015e293] 8bec       mov ebp,esp   ; housekeeping
[00002166][0015e28b][00002163] 6863210000 push 00002163 ; push DDD [0000216b][0015e287][00002170] e853f4ffff call 000015c3 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002170][001037c3][001037cb] 83c404     add esp,+04 ; exeuted DDD() [00002173][001037c7][0000218b] 5d         pop ebp     ; exeuted DDD()
[00002174][001037cb][00000000] c3         ret         ; exeuted DDD()
[0000218b][001037cb][00000000] 33c0       xor eax,eax ; main() [0000218d][001037cf][00000018] 5d         pop ebp     ; main() [0000218e][001037d3][00000000] c3         ret         ; main()
Number of Instructions Executed(10071) == 150 Pages

Just repeating your errors doesn't make it right.

See my other post where I explain the error, you are worht repeating it.

YOu are just too stupid.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)