Best selling author of Theory of Computation textbooks:
*Introduction To The Theory Of Computation 3RD, by sipser*
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/

Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

*When we apply the abort criteria* (elaborated above)
Will you halt if you never abort your simulation?
*Then H(D,D) is proven to meet this criteria*

*Proof that H(D,D) meets its abort criteria*

int D(int (*x)())
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{ Output("Input_Halts = ", H(D,D));
}

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ; begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp
[00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)

H: Begin Simulation Execution Trace Stored at:113075
Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ; enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp
[00001cf5][0011305d][00103031] 51 push ecx
[00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ; push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ; push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped
H(D,D) returns 0 to main()

*That was proof that H(D,D) meets its abort criteria*
H(D,D) correctly determines that itself is being called with its same
inputs and there are no conditional branch instructions between the
invocation of D(D) and its call to H(D,D).

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 15/03/24 17:20, olcott wrote:
> Best selling author of Theory of Computation textbooks:
> *Introduction To The Theory Of Computation 3RD, by sipser*
> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>
> Date 10/13/2022 11:29:23 AM
> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
> (He has neither reviewed nor agreed to anything else in this paper)
> (a) 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
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> *When we apply the abort criteria* (elaborated above)
> Will you halt if you never abort your simulation?
> *Then H(D,D) is proven to meet this criteria*
>
> *Proof that H(D,D) meets its abort criteria*
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
> }
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>
> H: Begin Simulation   Execution Trace Stored at:113075
> Address_of_H:1522
> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
> [00001cf5][0011305d][00103031] 51         push ecx
> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
> H: Recursive Simulation Detected Simulation Stopped
>                           H(D,D) returns 0 to main()
>
> *That was proof that H(D,D) meets its abort criteria*
> H(D,D) correctly determines that itself is being called with its same
> inputs and there are no conditional branch instructions between the
> invocation of D(D) and its call to H(D,D).
>
>

There are conditional branch instructions inside H(D,D). This is
obvious. Why do you keep lying?

On 3/15/2024 12:07 PM, immibis wrote:
> On 15/03/24 17:20, olcott wrote:
>> Best selling author of Theory of Computation textbooks:
>> *Introduction To The Theory Of Computation 3RD, by sipser*
>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>
>> Date 10/13/2022 11:29:23 AM
>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>> (He has neither reviewed nor agreed to anything else in this paper)
>> (a) 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
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> *When we apply the abort criteria* (elaborated above)
>> Will you halt if you never abort your simulation?
>> *Then H(D,D) is proven to meet this criteria*
>>
>> *Proof that H(D,D) meets its abort criteria*
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>> }
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>
>> H: Begin Simulation   Execution Trace Stored at:113075
>> Address_of_H:1522
>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>> [00001cf5][0011305d][00103031] 51         push ecx
>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>> H: Recursive Simulation Detected Simulation Stopped
>>                            H(D,D) returns 0 to main()
>>
>> *That was proof that H(D,D) meets its abort criteria*
>> H(D,D) correctly determines that itself is being called with its same
>> inputs and there are no conditional branch instructions between the
>> invocation of D(D) and its call to H(D,D).
>>
>>
>
> There are conditional branch instructions inside H(D,D). This is
> obvious. Why do you keep lying?

(a) 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

It is true that D(D) would never stop running unless the
outermost H(D,D) aborts its simulation thus meeting the
above criteria.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/24 9:20 AM, olcott wrote:
> Best selling author of Theory of Computation textbooks:
> *Introduction To The Theory Of Computation 3RD, by sipser*
> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>
> Date 10/13/2022 11:29:23 AM
> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
> (He has neither reviewed nor agreed to anything else in this paper)
> (a) 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
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> *When we apply the abort criteria* (elaborated above)
> Will you halt if you never abort your simulation?
> *Then H(D,D) is proven to meet this criteria*
>
> *Proof that H(D,D) meets its abort criteria*
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
> }
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>
> H: Begin Simulation   Execution Trace Stored at:113075
> Address_of_H:1522
> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
> [00001cf5][0011305d][00103031] 51         push ecx
> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
> H: Recursive Simulation Detected Simulation Stopped
>                           H(D,D) returns 0 to main()
>
> *That was proof that H(D,D) meets its abort criteria*
> H(D,D) correctly determines that itself is being called with its same
> inputs and there are no conditional branch instructions between the
> invocation of D(D) and its call to H(D,D).
>
>

Except that D calling H(D,D) does NOT prove the required (a), since the
simulated D WILL stop running because *ITS* H will abort *ITS*
simulation and returm 0 so that simulated D will halt.

Unless you think it is right to arrest John for the crime of this twin
brother Jack, *THIS* H can't claim that it actually NEEDED to abort.

If you change H to not abort, then you no longer have the same D, so you
invalidated the problem statement.

By Linz, H^ (which you call D here) is DEFINED to use a copy of the
decider that will be claimed to get the right value.

Since you never claim the non-aborting alternate version of H gets the
right value for its H^/D, then we don't need to look at it.

You are just showing you don't understand the problem statement, and are
demonstrating that you have wasted years on your strawman cause by your
own misunderstanding of the problem (even though TOLD that your setup
was diffferent than the problem you claimed to be solving).

On 3/15/2024 12:36 PM, Richard Damon wrote:
> On 3/15/24 9:20 AM, olcott wrote:
>> Best selling author of Theory of Computation textbooks:
>> *Introduction To The Theory Of Computation 3RD, by sipser*
>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>
>> Date 10/13/2022 11:29:23 AM
>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>> (He has neither reviewed nor agreed to anything else in this paper)
>> (a) 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
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> *When we apply the abort criteria* (elaborated above)
>> Will you halt if you never abort your simulation?
>> *Then H(D,D) is proven to meet this criteria*
>>
>> *Proof that H(D,D) meets its abort criteria*
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>> }
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>
>> H: Begin Simulation   Execution Trace Stored at:113075
>> Address_of_H:1522
>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>> [00001cf5][0011305d][00103031] 51         push ecx
>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>> H: Recursive Simulation Detected Simulation Stopped
>>                            H(D,D) returns 0 to main()
>>
>> *That was proof that H(D,D) meets its abort criteria*
>> H(D,D) correctly determines that itself is being called with its same
>> inputs and there are no conditional branch instructions between the
>> invocation of D(D) and its call to H(D,D).
>>
>>
>
> Except that D calling H(D,D) does NOT prove the required (a), since the
> simulated D WILL stop running because *ITS* H will abort *ITS*
> simulation and returm 0 so that simulated D will halt.
You keep saying that H(D,D) never really needs to abort the
simulation of its input because after H(D,D) has aborted the
simulation of this input it no longer needs to be aborted.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/2024 11:20 AM, olcott wrote:
> Best selling author of Theory of Computation textbooks:
> *Introduction To The Theory Of Computation 3RD, by sipser*
> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>
> Date 10/13/2022 11:29:23 AM
> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
> (He has neither reviewed nor agreed to anything else in this paper)
> (a) 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
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> *When we apply the abort criteria* (elaborated above)
> Will you halt if you never abort your simulation?
> *Then H(D,D) is proven to meet this criteria*
>
> *Proof that H(D,D) meets its abort criteria*
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
> }
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>
> H: Begin Simulation   Execution Trace Stored at:113075
> Address_of_H:1522
> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
> [00001cf5][0011305d][00103031] 51         push ecx
> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
> H: Recursive Simulation Detected Simulation Stopped
>                           H(D,D) returns 0 to main()
>
> *That was proof that H(D,D) meets its abort criteria*
> H(D,D) correctly determines that itself is being called with its same
> inputs and there are no conditional branch instructions between the
> invocation of D(D) and its call to H(D,D).
>
>

On 3/15/2024 12:44 PM, Richard Damon wrote:
> On 3/15/24 10:11 AM, olcott wrote:
>> D(D) specifies an infinite chain of H(D,D) unless D(D) is
>> aborted at some point. The outermost H(D,D) always has
>> seen a longer execution trace than any of the inner ones.
>>
>
> Right, *AT SOME POINT* but not nessesarily HERE.
>
> No, the outermose has seen more execution trace then
> the innerones have at the point that H aborts their
> simulation.
>

(a) 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

It seems like you are agreeing with me that H(D,D)==0
is correct for the above criteria.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/24 10:23 AM, olcott wrote:
> On 3/15/2024 12:07 PM, immibis wrote:
>> On 15/03/24 17:20, olcott wrote:
>>> Best selling author of Theory of Computation textbooks:
>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>
>>> Date 10/13/2022 11:29:23 AM
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) 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
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> *When we apply the abort criteria* (elaborated above)
>>> Will you halt if you never abort your simulation?
>>> *Then H(D,D) is proven to meet this criteria*
>>>
>>> *Proof that H(D,D) meets its abort criteria*
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>> }
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>
>>> H: Begin Simulation   Execution Trace Stored at:113075
>>> Address_of_H:1522
>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>> [00001cf5][0011305d][00103031] 51         push ecx
>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>> H: Recursive Simulation Detected Simulation Stopped
>>>                            H(D,D) returns 0 to main()
>>>
>>> *That was proof that H(D,D) meets its abort criteria*
>>> H(D,D) correctly determines that itself is being called with its same
>>> inputs and there are no conditional branch instructions between the
>>> invocation of D(D) and its call to H(D,D).
>>>
>>>
>>
>> There are conditional branch instructions inside H(D,D). This is
>> obvious. Why do you keep lying?
>
> (a) 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
>
> It is true that D(D) would never stop running unless the
> outermost H(D,D) aborts its simulation thus meeting the
> above criteria.
>

Nope, not if D is claimed to be the equivalent of Linz H^.

If you are willing to DISAVOW any posssible conntection to that we can
discuss that version, but then you are admitting this is just a time
wasting change of topic.

The issue becomes a definition of identity.

IF we are in an equivalency to Linz H/H^, then the H that D calls is a
seperate identity to the H that is simulating that D.

Thus, the outer H doesn't NEED to abort, as replacing it (not CHANGING
it, as your structure doesn't allow changing it will keeping D defined
the same as Linz H^) with a version that doesn't abort then we see that
D will call H(D,D) which will simulate that input until it sees it call
H(D,D) and then abort and return.

Thus the outer H, although it DOES abort, doesn't abort due to having
proven a NEED to abort for the input it has been given (which also
happens to abort and return)

On 3/15/24 10:52 AM, olcott wrote:
> On 3/15/2024 12:36 PM, Richard Damon wrote:
>> On 3/15/24 9:20 AM, olcott wrote:
>>> Best selling author of Theory of Computation textbooks:
>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>
>>> Date 10/13/2022 11:29:23 AM
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) 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
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> *When we apply the abort criteria* (elaborated above)
>>> Will you halt if you never abort your simulation?
>>> *Then H(D,D) is proven to meet this criteria*
>>>
>>> *Proof that H(D,D) meets its abort criteria*
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>> }
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>
>>> H: Begin Simulation   Execution Trace Stored at:113075
>>> Address_of_H:1522
>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>> [00001cf5][0011305d][00103031] 51         push ecx
>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>> H: Recursive Simulation Detected Simulation Stopped
>>>                            H(D,D) returns 0 to main()
>>>
>>> *That was proof that H(D,D) meets its abort criteria*
>>> H(D,D) correctly determines that itself is being called with its same
>>> inputs and there are no conditional branch instructions between the
>>> invocation of D(D) and its call to H(D,D).
>>>
>>>
>>
>> Except that D calling H(D,D) does NOT prove the required (a), since
>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>> simulation and returm 0 so that simulated D will halt.
> You keep saying that H(D,D) never really needs to abort the
> simulation of its input because after H(D,D) has aborted the
> simulation of this input it no longer needs to be aborted.
>

You confuse the identities.

*THIS* (the outer instance) doesn't need to abort its simulation,
because since the *OTHER* (the simulated version) does, and thus the
correct simulation of the input provided does halt.

That (apparently intentional) confusion just shows that you are being
deceitful or stupid (if you really don't know better).

This becomes a matter of interpreting the intended SEMANTICS of the call
to H in D.

To be like Linz (as you claim), it means to call the algorithm of the H
that is finally decided to be the correct on.

To be what you are trying to claim to be correct, it needs to be to call
the algorithm of whatever decider is trying to decide it. (and thus not
the problem you claim to be working on)

Your interpretation makes D NOT a "Computation" and thus not a valid
target of the Halting Question, and thus your whole case MOOT, as an
invalid question.

It is IMPOSSIBLE to define a computation or a Turing Machine, that
somehow references the thing trying to look at it.

Your failure to understand that show a FUNDAMENTAL lack of understanding
of the field you are claiming to make important revelations in, which
just shows your stupidity.

On 3/15/2024 1:15 PM, Richard Damon wrote:
> On 3/15/24 10:23 AM, olcott wrote:
>> On 3/15/2024 12:07 PM, immibis wrote:
>>> On 15/03/24 17:20, olcott wrote:
>>>> Best selling author of Theory of Computation textbooks:
>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>
>>>> Date 10/13/2022 11:29:23 AM
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) 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
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *When we apply the abort criteria* (elaborated above)
>>>> Will you halt if you never abort your simulation?
>>>> *Then H(D,D) is proven to meet this criteria*
>>>>
>>>> *Proof that H(D,D) meets its abort criteria*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>> }
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_H:1522
>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>                            H(D,D) returns 0 to main()
>>>>
>>>> *That was proof that H(D,D) meets its abort criteria*
>>>> H(D,D) correctly determines that itself is being called with its
>>>> same inputs and there are no conditional branch instructions between
>>>> the invocation of D(D) and its call to H(D,D).
>>>>
>>>>
>>>
>>> There are conditional branch instructions inside H(D,D). This is
>>> obvious. Why do you keep lying?
>>
>> (a) 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
>>
>> It is true that D(D) would never stop running unless the
>> outermost H(D,D) aborts its simulation thus meeting the
>> above criteria.
>>
>
> Nope, not if D is claimed to be the equivalent of Linz H^.
>
> If you are willing to DISAVOW any posssible conntection to that we can
> discuss that version, but then you are admitting this is just a time
> wasting change of topic.
>
> The issue becomes a definition of identity.
>
> IF we are in an equivalency to Linz H/H^, then the H that D calls is a
> seperate identity to the H that is simulating that D.
>
> Thus, the outer H doesn't NEED to abort,

(a) 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

That is incorrect yet too difficult for you to understand
that it is incorrect until after you first understand that
D(D,D)==0 is correct for the above criteria.

> as replacing it (not CHANGING
> it, as your structure doesn't allow changing it will keeping D defined
> the same as Linz H^) with a version that doesn't abort then we see that
> D will call H(D,D) which will simulate that input until it sees it call
> H(D,D) and then abort and return.
>
> Thus the outer H, although it DOES abort, doesn't abort due to having
> proven a NEED to abort for the input it has been given (which also
> happens to abort and return)
>

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/2024 1:24 PM, Richard Damon wrote:
> On 3/15/24 10:52 AM, olcott wrote:
>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>> On 3/15/24 9:20 AM, olcott wrote:
>>>> Best selling author of Theory of Computation textbooks:
>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>
>>>> Date 10/13/2022 11:29:23 AM
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) 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
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *When we apply the abort criteria* (elaborated above)
>>>> Will you halt if you never abort your simulation?
>>>> *Then H(D,D) is proven to meet this criteria*
>>>>
>>>> *Proof that H(D,D) meets its abort criteria*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>> }
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_H:1522
>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>                            H(D,D) returns 0 to main()
>>>>
>>>> *That was proof that H(D,D) meets its abort criteria*
>>>> H(D,D) correctly determines that itself is being called with its
>>>> same inputs and there are no conditional branch instructions between
>>>> the invocation of D(D) and its call to H(D,D).
>>>>
>>>>
>>>
>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>> simulation and returm 0 so that simulated D will halt.
>> You keep saying that H(D,D) never really needs to abort the
>> simulation of its input because after H(D,D) has aborted the
>> simulation of this input it no longer needs to be aborted.
>>
>
> You confuse the identities.
>
> *THIS* (the outer instance) doesn't need to abort its simulation,
> because since the *OTHER* (the simulated version) does, and thus the
> correct simulation of the input provided does halt.
>

The first H(D,D) to see that the abort criteria has been met
(the outermost one) must abort the simulation of its input or
none of them ever abort.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/2024 1:15 PM, Richard Damon wrote:
> On 3/15/24 10:23 AM, olcott wrote:
>> On 3/15/2024 12:07 PM, immibis wrote:
>>> On 15/03/24 17:20, olcott wrote:
>>>> Best selling author of Theory of Computation textbooks:
>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>
>>>> Date 10/13/2022 11:29:23 AM
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) 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
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *When we apply the abort criteria* (elaborated above)
>>>> Will you halt if you never abort your simulation?
>>>> *Then H(D,D) is proven to meet this criteria*
>>>>
>>>> *Proof that H(D,D) meets its abort criteria*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>> }
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_H:1522
>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>                            H(D,D) returns 0 to main()
>>>>
>>>> *That was proof that H(D,D) meets its abort criteria*
>>>> H(D,D) correctly determines that itself is being called with its
>>>> same inputs and there are no conditional branch instructions between
>>>> the invocation of D(D) and its call to H(D,D).
>>>>
>>>>
>>>
>>> There are conditional branch instructions inside H(D,D). This is
>>> obvious. Why do you keep lying?
>>
>> (a) 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
>>
>> It is true that D(D) would never stop running unless the
>> outermost H(D,D) aborts its simulation thus meeting the
>> above criteria.
>>
>
> Nope, not if D is claimed to be the equivalent of Linz H^.
>
> If you are willing to DISAVOW any posssible conntection to that we can
> discuss that version, but then you are admitting this is just a time
> wasting change of topic.
>
> The issue becomes a definition of identity.
>
> IF we are in an equivalency to Linz H/H^, then the H that D calls is a
> seperate identity to the H that is simulating that D.
>
> Thus, the outer H doesn't NEED to abort,

The first H(D,D) to see that the abort criteria has been met
(the outermost one) must abort the simulation of its input or
none of them ever abort.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 15/03/24 18:23, olcott wrote:
> On 3/15/2024 12:07 PM, immibis wrote:
>> On 15/03/24 17:20, olcott wrote:
>>> Best selling author of Theory of Computation textbooks:
>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>
>>> Date 10/13/2022 11:29:23 AM
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) 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
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> *When we apply the abort criteria* (elaborated above)
>>> Will you halt if you never abort your simulation?
>>> *Then H(D,D) is proven to meet this criteria*
>>>
>>> *Proof that H(D,D) meets its abort criteria*
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>> }
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>
>>> H: Begin Simulation   Execution Trace Stored at:113075
>>> Address_of_H:1522
>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>> [00001cf5][0011305d][00103031] 51         push ecx
>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>> H: Recursive Simulation Detected Simulation Stopped
>>>                            H(D,D) returns 0 to main()
>>>
>>> *That was proof that H(D,D) meets its abort criteria*
>>> H(D,D) correctly determines that itself is being called with its same
>>> inputs and there are no conditional branch instructions between the
>>> invocation of D(D) and its call to H(D,D).
>>>
>>>
>>
>> There are conditional branch instructions inside H(D,D). This is
>> obvious. Why do you keep lying?
>
> (a) 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
>
> It is true that D(D) would never stop running unless the
> outermost H(D,D) aborts its simulation thus meeting the
> above criteria.
>
It is true that D(D) would never stop running unless the SIMULATED
H(D,D) aborts its simulation or does not run a simulation or the
simulation halts.

On 15/03/24 18:52, olcott wrote:
> On 3/15/2024 12:36 PM, Richard Damon wrote:
>> On 3/15/24 9:20 AM, olcott wrote:
>>> Best selling author of Theory of Computation textbooks:
>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>
>>> Date 10/13/2022 11:29:23 AM
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) 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
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> *When we apply the abort criteria* (elaborated above)
>>> Will you halt if you never abort your simulation?
>>> *Then H(D,D) is proven to meet this criteria*
>>>
>>> *Proof that H(D,D) meets its abort criteria*
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>> }
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>
>>> H: Begin Simulation   Execution Trace Stored at:113075
>>> Address_of_H:1522
>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>> [00001cf5][0011305d][00103031] 51         push ecx
>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>> H: Recursive Simulation Detected Simulation Stopped
>>>                            H(D,D) returns 0 to main()
>>>
>>> *That was proof that H(D,D) meets its abort criteria*
>>> H(D,D) correctly determines that itself is being called with its same
>>> inputs and there are no conditional branch instructions between the
>>> invocation of D(D) and its call to H(D,D).
>>>
>>>
>>
>> Except that D calling H(D,D) does NOT prove the required (a), since
>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>> simulation and returm 0 so that simulated D will halt.
> You keep saying that H(D,D) never really needs to abort the
> simulation of its input because after H(D,D) has aborted the
> simulation of this input it no longer needs to be aborted.
>
You keep thinking there is more than one H(D,D) and then when it's
convenient for you you think there is only one H(D,D). Why is that?

On 3/15/2024 1:37 PM, immibis wrote:
> On 15/03/24 18:23, olcott wrote:
>> On 3/15/2024 12:07 PM, immibis wrote:
>>> On 15/03/24 17:20, olcott wrote:
>>>> Best selling author of Theory of Computation textbooks:
>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>
>>>> Date 10/13/2022 11:29:23 AM
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) 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
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *When we apply the abort criteria* (elaborated above)
>>>> Will you halt if you never abort your simulation?
>>>> *Then H(D,D) is proven to meet this criteria*
>>>>
>>>> *Proof that H(D,D) meets its abort criteria*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>> }
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_H:1522
>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>                            H(D,D) returns 0 to main()
>>>>
>>>> *That was proof that H(D,D) meets its abort criteria*
>>>> H(D,D) correctly determines that itself is being called with its
>>>> same inputs and there are no conditional branch instructions between
>>>> the invocation of D(D) and its call to H(D,D).
>>>>
>>>>
>>>
>>> There are conditional branch instructions inside H(D,D). This is
>>> obvious. Why do you keep lying?
>>
>> (a) 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
>>
>> It is true that D(D) would never stop running unless the
>> outermost H(D,D) aborts its simulation thus meeting the
>> above criteria.
>>
> It is true that D(D) would never stop running unless the SIMULATED
> H(D,D) aborts its simulation or does not run a simulation or the
> simulation halts.

The first H(D,D) to see that the abort criteria has been met
(the outermost one) must abort the simulation of its input or
none of them ever abort.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/2024 1:38 PM, immibis wrote:
> On 15/03/24 18:52, olcott wrote:
>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>> On 3/15/24 9:20 AM, olcott wrote:
>>>> Best selling author of Theory of Computation textbooks:
>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>
>>>> Date 10/13/2022 11:29:23 AM
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) 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
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *When we apply the abort criteria* (elaborated above)
>>>> Will you halt if you never abort your simulation?
>>>> *Then H(D,D) is proven to meet this criteria*
>>>>
>>>> *Proof that H(D,D) meets its abort criteria*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>> }
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_H:1522
>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>                            H(D,D) returns 0 to main()
>>>>
>>>> *That was proof that H(D,D) meets its abort criteria*
>>>> H(D,D) correctly determines that itself is being called with its
>>>> same inputs and there are no conditional branch instructions between
>>>> the invocation of D(D) and its call to H(D,D).
>>>>
>>>>
>>>
>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>> simulation and returm 0 so that simulated D will halt.
>> You keep saying that H(D,D) never really needs to abort the
>> simulation of its input because after H(D,D) has aborted the
>> simulation of this input it no longer needs to be aborted.
>>
> You keep thinking there is more than one H(D,D) and then when it's
> convenient for you you think there is only one H(D,D). Why is that?

The first H(D,D) to see that the abort criteria has been met
(the outermost one) must abort the simulation of its input or
none of them ever abort.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 15/03/24 19:39, olcott wrote:
> On 3/15/2024 1:38 PM, immibis wrote:
>> On 15/03/24 18:52, olcott wrote:
>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>> Best selling author of Theory of Computation textbooks:
>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>
>>>>> Date 10/13/2022 11:29:23 AM
>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>> correct*
>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>> (a) 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
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> *When we apply the abort criteria* (elaborated above)
>>>>> Will you halt if you never abort your simulation?
>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>
>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(D,D));
>>>>> }
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_H:1522
>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>                            H(D,D) returns 0 to main()
>>>>>
>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>> H(D,D) correctly determines that itself is being called with its
>>>>> same inputs and there are no conditional branch instructions
>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>
>>>>>
>>>>
>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>> simulation and returm 0 so that simulated D will halt.
>>> You keep saying that H(D,D) never really needs to abort the
>>> simulation of its input because after H(D,D) has aborted the
>>> simulation of this input it no longer needs to be aborted.
>>>
>> You keep thinking there is more than one H(D,D) and then when it's
>> convenient for you you think there is only one H(D,D). Why is that?
>
> The first H(D,D) to see that the abort criteria has been met
> (the outermost one) must abort the simulation of its input or
> none of them ever abort.
>

that's wrong. They all abort, so if we prevent the first one from
aborting, the second one will abort. If we prevent the first and second
ones from aborting, the third one will abort. Why do you lie so blatantly?

On 15/03/24 19:35, olcott wrote:
> On 3/15/2024 1:24 PM, Richard Damon wrote:
>> On 3/15/24 10:52 AM, olcott wrote:
>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>> Best selling author of Theory of Computation textbooks:
>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>
>>>>> Date 10/13/2022 11:29:23 AM
>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>> correct*
>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>> (a) 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
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> *When we apply the abort criteria* (elaborated above)
>>>>> Will you halt if you never abort your simulation?
>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>
>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(D,D));
>>>>> }
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_H:1522
>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>                            H(D,D) returns 0 to main()
>>>>>
>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>> H(D,D) correctly determines that itself is being called with its
>>>>> same inputs and there are no conditional branch instructions
>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>
>>>>>
>>>>
>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>> simulation and returm 0 so that simulated D will halt.
>>> You keep saying that H(D,D) never really needs to abort the
>>> simulation of its input because after H(D,D) has aborted the
>>> simulation of this input it no longer needs to be aborted.
>>>
>>
>> You confuse the identities.
>>
>> *THIS* (the outer instance) doesn't need to abort its simulation,
>> because since the *OTHER* (the simulated version) does, and thus the
>> correct simulation of the input provided does halt.
>>
>
> The first H(D,D) to see that the abort criteria has been met
> (the outermost one) must abort the simulation of its input or
> none of them ever abort.
>
Posting the exact same message 5 times doesn't make it correct.

On 3/15/24 11:31 AM, olcott wrote:
> On 3/15/2024 1:15 PM, Richard Damon wrote:
>> On 3/15/24 10:23 AM, olcott wrote:
>>> On 3/15/2024 12:07 PM, immibis wrote:
>>>> On 15/03/24 17:20, olcott wrote:
>>>>> Best selling author of Theory of Computation textbooks:
>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>
>>>>> Date 10/13/2022 11:29:23 AM
>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>> correct*
>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>> (a) 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
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> *When we apply the abort criteria* (elaborated above)
>>>>> Will you halt if you never abort your simulation?
>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>
>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(D,D));
>>>>> }
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_H:1522
>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>                            H(D,D) returns 0 to main()
>>>>>
>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>> H(D,D) correctly determines that itself is being called with its
>>>>> same inputs and there are no conditional branch instructions
>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>
>>>>>
>>>>
>>>> There are conditional branch instructions inside H(D,D). This is
>>>> obvious. Why do you keep lying?
>>>
>>> (a) 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
>>>
>>> It is true that D(D) would never stop running unless the
>>> outermost H(D,D) aborts its simulation thus meeting the
>>> above criteria.
>>>
>>
>> Nope, not if D is claimed to be the equivalent of Linz H^.
>>
>> If you are willing to DISAVOW any posssible conntection to that we can
>> discuss that version, but then you are admitting this is just a time
>> wasting change of topic.
>>
>> The issue becomes a definition of identity.
>>
>> IF we are in an equivalency to Linz H/H^, then the H that D calls is a
>> seperate identity to the H that is simulating that D.
>>
>> Thus, the outer H doesn't NEED to abort,
>
> (a) 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
>
> That is incorrect yet too difficult for you to understand
> that it is incorrect until after you first understand that
> D(D,D)==0 is correct for the above criteria.

D isn't defined to be a "decider" so its return values are not answers
to any particular question.

H(D,D) == 0 can't be "Correct" for a Halt Decider, as D(D) halts.

H didn't correctly determines that its simulated D would never stop
running unless abortdd, since correctly simulating its input (without
chanig ANY of the code referenced by D, whichw ould change D) shows that
it DOES come to a stop, as shown by H1.

So, H is just wrong.

And you are shown to be a LIAR.

>
>> as replacing it (not CHANGING it, as your structure doesn't allow
>> changing it will keeping D defined the same as Linz H^) with a version
>> that doesn't abort then we see that D will call H(D,D) which will
>> simulate that input until it sees it call H(D,D) and then abort and
>> return.
>>
>> Thus the outer H, although it DOES abort, doesn't abort due to having
>> proven a NEED to abort for the input it has been given (which also
>> happens to abort and return)
>>
>

On 3/15/24 11:35 AM, olcott wrote:
> On 3/15/2024 1:24 PM, Richard Damon wrote:
>> On 3/15/24 10:52 AM, olcott wrote:
>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>> Best selling author of Theory of Computation textbooks:
>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>
>>>>> Date 10/13/2022 11:29:23 AM
>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>> correct*
>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>> (a) 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
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> *When we apply the abort criteria* (elaborated above)
>>>>> Will you halt if you never abort your simulation?
>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>
>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(D,D));
>>>>> }
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_H:1522
>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>                            H(D,D) returns 0 to main()
>>>>>
>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>> H(D,D) correctly determines that itself is being called with its
>>>>> same inputs and there are no conditional branch instructions
>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>
>>>>>
>>>>
>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>> simulation and returm 0 so that simulated D will halt.
>>> You keep saying that H(D,D) never really needs to abort the
>>> simulation of its input because after H(D,D) has aborted the
>>> simulation of this input it no longer needs to be aborted.
>>>
>>
>> You confuse the identities.
>>
>> *THIS* (the outer instance) doesn't need to abort its simulation,
>> because since the *OTHER* (the simulated version) does, and thus the
>> correct simulation of the input provided does halt.
>>
>
> The first H(D,D) to see that the abort criteria has been met
> (the outermost one) must abort the simulation of its input or
> none of them ever abort.
>

No, it doesn't. It sees that your incorrect implementation of that
requirement is meet, and thus gives the wrong answer.

H1 shows that the correct simuation of the input to D (which is what the
criteria you quote looks at) does stop and thus H did not meet its
requirements to use step b, but did so anyway.

H DECIEVES ITSELF, by imagining it is something it isn't in a way that
changes the input to something it isn't and answer, correctly for the
wrong question, and thus lies. Just a you do for calling it correct.

If the H that you claim is correct does abort, then D uses that H that
does that, and thus H's logic is unsound.

On 3/15/24 11:38 AM, immibis wrote:
> On 15/03/24 18:52, olcott wrote:
>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>> On 3/15/24 9:20 AM, olcott wrote:
>>>> Best selling author of Theory of Computation textbooks:
>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>
>>>> Date 10/13/2022 11:29:23 AM
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) 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
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> *When we apply the abort criteria* (elaborated above)
>>>> Will you halt if you never abort your simulation?
>>>> *Then H(D,D) is proven to meet this criteria*
>>>>
>>>> *Proof that H(D,D) meets its abort criteria*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>> }
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>
>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_H:1522
>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>                            H(D,D) returns 0 to main()
>>>>
>>>> *That was proof that H(D,D) meets its abort criteria*
>>>> H(D,D) correctly determines that itself is being called with its
>>>> same inputs and there are no conditional branch instructions between
>>>> the invocation of D(D) and its call to H(D,D).
>>>>
>>>>
>>>
>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>> simulation and returm 0 so that simulated D will halt.
>> You keep saying that H(D,D) never really needs to abort the
>> simulation of its input because after H(D,D) has aborted the
>> simulation of this input it no longer needs to be aborted.
>>
> You keep thinking there is more than one H(D,D) and then when it's
> convenient for you you think there is only one H(D,D). Why is that?

But there ARE more than one instance of the computation performed by the
function.

It isn't the code of the function that defines the full computation, it
is the pairing of that algorithm with its input, and that occurs
seperately in multiple place in the execution history of this problem,
and each one is a SEPERATE (but IDENTICAL) computation (assuming H IS a
pure algorithm and thus forms a computation when called)

On 3/15/2024 1:45 PM, immibis wrote:
> On 15/03/24 19:39, olcott wrote:
>> On 3/15/2024 1:38 PM, immibis wrote:
>>> On 15/03/24 18:52, olcott wrote:
>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>
>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>>> correct*
>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>> (a) 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
>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>>
>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>> Will you halt if you never abort your simulation?
>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>
>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>> }
>>>>>>
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin
>>>>>> main()
>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>
>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>> Address_of_H:1522
>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call
>>>>>> H(D,D)
>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>                            H(D,D) returns 0 to main()
>>>>>>
>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>> H(D,D) correctly determines that itself is being called with its
>>>>>> same inputs and there are no conditional branch instructions
>>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>>
>>>>>>
>>>>>
>>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>> simulation and returm 0 so that simulated D will halt.
>>>> You keep saying that H(D,D) never really needs to abort the
>>>> simulation of its input because after H(D,D) has aborted the
>>>> simulation of this input it no longer needs to be aborted.
>>>>
>>> You keep thinking there is more than one H(D,D) and then when it's
>>> convenient for you you think there is only one H(D,D). Why is that?
>>
>> The first H(D,D) to see that the abort criteria has been met
>> (the outermost one) must abort the simulation of its input or
>> none of them ever abort.
>>
>
> that's wrong. They all abort,

I was baffled by this for three days when I first investigated this.
Because every H has the exact same code, if the first one to see that
the abort criteria has been met does not abort then none of them abort.

> so if we prevent the first one from
> aborting, the second one will abort. If we prevent the first and second
> ones from aborting, the third one will abort. Why do you lie so blatantly?

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/2024 1:45 PM, immibis wrote:
> On 15/03/24 19:35, olcott wrote:
>> On 3/15/2024 1:24 PM, Richard Damon wrote:
>>> On 3/15/24 10:52 AM, olcott wrote:
>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>
>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>>> correct*
>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>> (a) 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
>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>>
>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>> Will you halt if you never abort your simulation?
>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>
>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>> }
>>>>>>
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin
>>>>>> main()
>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>
>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>> Address_of_H:1522
>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call
>>>>>> H(D,D)
>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>                            H(D,D) returns 0 to main()
>>>>>>
>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>> H(D,D) correctly determines that itself is being called with its
>>>>>> same inputs and there are no conditional branch instructions
>>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>>
>>>>>>
>>>>>
>>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>> simulation and returm 0 so that simulated D will halt.
>>>> You keep saying that H(D,D) never really needs to abort the
>>>> simulation of its input because after H(D,D) has aborted the
>>>> simulation of this input it no longer needs to be aborted.
>>>>
>>>
>>> You confuse the identities.
>>>
>>> *THIS* (the outer instance) doesn't need to abort its simulation,
>>> because since the *OTHER* (the simulated version) does, and thus the
>>> correct simulation of the input provided does halt.
>>>
>>
>> The first H(D,D) to see that the abort criteria has been met
>> (the outermost one) must abort the simulation of its input or
>> none of them ever abort.
>>
> Posting the exact same message 5 times doesn't make it correct.

The fact that it is correct proves that it is correct.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/24 11:39 AM, olcott wrote:
> On 3/15/2024 1:38 PM, immibis wrote:
>> On 15/03/24 18:52, olcott wrote:
>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>> Best selling author of Theory of Computation textbooks:
>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>
>>>>> Date 10/13/2022 11:29:23 AM
>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>> correct*
>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>> (a) 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
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> *When we apply the abort criteria* (elaborated above)
>>>>> Will you halt if you never abort your simulation?
>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>
>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(D,D));
>>>>> }
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_H:1522
>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>                            H(D,D) returns 0 to main()
>>>>>
>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>> H(D,D) correctly determines that itself is being called with its
>>>>> same inputs and there are no conditional branch instructions
>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>
>>>>>
>>>>
>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>> simulation and returm 0 so that simulated D will halt.
>>> You keep saying that H(D,D) never really needs to abort the
>>> simulation of its input because after H(D,D) has aborted the
>>> simulation of this input it no longer needs to be aborted.
>>>
>> You keep thinking there is more than one H(D,D) and then when it's
>> convenient for you you think there is only one H(D,D). Why is that?
>
> The first H(D,D) to see that the abort criteria has been met
> (the outermost one) must abort the simulation of its input or
> none of them ever abort.
>

But since it does, which is your definition of H, the others do, so THIS
algorithm for H doesn't NEED to, but does.

The input doesn't actually "refer" to this outer H, but just happen to
be copies (at least if you are going to claim to be the equivalent of
the linz H / H^ system), you can't tie the various version running into
a single identity.

If you try to define the H in D to be actually REFERING to the same H,
and not just an optimization to help realizability, then you run into
the problem that you have left the equivalence to that which you want to
claim, and thus your whole argument is invalid.

On 3/15/2024 1:31 PM, olcott wrote:
> On 3/15/2024 1:15 PM, Richard Damon wrote:
>> On 3/15/24 10:23 AM, olcott wrote:
>>> On 3/15/2024 12:07 PM, immibis wrote:
>>>> On 15/03/24 17:20, olcott wrote:
>>>>> Best selling author of Theory of Computation textbooks:
>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>
>>>>> Date 10/13/2022 11:29:23 AM
>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>> correct*
>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>> (a) 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
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>> *When we apply the abort criteria* (elaborated above)
>>>>> Will you halt if you never abort your simulation?
>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>
>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(D,D));
>>>>> }
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>
>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_H:1522
>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>                            H(D,D) returns 0 to main()
>>>>>
>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>> H(D,D) correctly determines that itself is being called with its
>>>>> same inputs and there are no conditional branch instructions
>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>
>>>>>
>>>>
>>>> There are conditional branch instructions inside H(D,D). This is
>>>> obvious. Why do you keep lying?
>>>
>>> (a) 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
>>>
>>> It is true that D(D) would never stop running unless the
>>> outermost H(D,D) aborts its simulation thus meeting the
>>> above criteria.
>>>
>>
>> Nope, not if D is claimed to be the equivalent of Linz H^.
>>
>> If you are willing to DISAVOW any posssible conntection to that we can
>> discuss that version, but then you are admitting this is just a time
>> wasting change of topic.
>>
>> The issue becomes a definition of identity.
>>
>> IF we are in an equivalency to Linz H/H^, then the H that D calls is a
>> seperate identity to the H that is simulating that D.
>>
>> Thus, the outer H doesn't NEED to abort,
>
> (a) 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
>
> That is incorrect yet too difficult for you to understand
> that it is incorrect until after you first understand that
> D(D,D)==0 is correct for the above criteria.
>

Typo I meant H(D,D).

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/2024 1:59 PM, Richard Damon wrote:
> On 3/15/24 11:35 AM, olcott wrote:
>> On 3/15/2024 1:24 PM, Richard Damon wrote:
>>> On 3/15/24 10:52 AM, olcott wrote:
>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>
>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>>> correct*
>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>> (a) 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
>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>>
>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>> Will you halt if you never abort your simulation?
>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>
>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>> }
>>>>>>
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin
>>>>>> main()
>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>
>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>> Address_of_H:1522
>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call
>>>>>> H(D,D)
>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>                            H(D,D) returns 0 to main()
>>>>>>
>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>> H(D,D) correctly determines that itself is being called with its
>>>>>> same inputs and there are no conditional branch instructions
>>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>>
>>>>>>
>>>>>
>>>>> Except that D calling H(D,D) does NOT prove the required (a), since
>>>>> the simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>> simulation and returm 0 so that simulated D will halt.
>>>> You keep saying that H(D,D) never really needs to abort the
>>>> simulation of its input because after H(D,D) has aborted the
>>>> simulation of this input it no longer needs to be aborted.
>>>>
>>>
>>> You confuse the identities.
>>>
>>> *THIS* (the outer instance) doesn't need to abort its simulation,
>>> because since the *OTHER* (the simulated version) does, and thus the
>>> correct simulation of the input provided does halt.
>>>
>>
>> The first H(D,D) to see that the abort criteria has been met
>> (the outermost one) must abort the simulation of its input or
>> none of them ever abort.
>>
>
> No, it doesn't. It sees that your incorrect implementation of that
> requirement is meet, and thus gives the wrong answer.
>
> H1 shows that the correct simuation of the input to D (which is what the
> criteria you quote looks at) does stop and thus H did not meet its
> requirements to use step b, but did so anyway.
>
> H DECIEVES ITSELF, by imagining it is something it isn't in a way that
> changes the input to something it isn't and answer, correctly for the
> wrong question, and thus lies. Just a you do for calling it correct.
>
> If the H that you claim is correct does abort, then D uses that H that
> does that, and thus H's logic is unsound.

It is an easily verified fact that if no H(D,D) aborts its
simulation that D(D) never halts.

It is also a verified fact (yet not quite as easy) that unless
the outermost one aborts its simulation then none of them do.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer