On 3/15/2024 2:06 PM, Richard Damon wrote:
> 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

never begin to be simulated.

> do, so THIS
> algorithm for H doesn't NEED to, but does.
>

H(D,D) cannot simply wait for another instance of itself to do something
otherwise all instances of H are waiting on the next one.

> 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.

--
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 12:06 PM, olcott wrote:
> 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).
>
>

WHich I assumed as a possibility and refuted.

H(D,D) == 0 can't be the correct answer for a Halting Decider as D(D)
Halts, so the correct answer would be 1.

0 != 1, so H was wrong, because H didn't actually meet its requirement
to correctly determine that the CORRECT simulaiton of its input (which
it turns out it doesn't do) would never stop.

All it did was look at the strawman case of Hn(Dn,Dn) where Dn uses Hn,
but since Hn != the H that gives the answer, this is just a strawman and
H deceived itself, just like you did.

This has been explained enough, that you repeating it has become a
deliberate lie or proof of incompetence.

On 3/15/24 11:37 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,
>
> 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.
>

Nope, explained many times recently.

You are now just blantently lying, since you obviously don't have a
valid reason to refute the errors pointed out.

On 3/15/24 11:38 AM, olcott wrote:
> 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.
>

Nope, Error pointed out many times recently, so you are just admitting
to being a blantant liar, or utterly incompetent.

On 3/15/24 12:04 PM, olcott wrote:
> 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.
>

The fact that H(D,D) returns 0, saying D(D) is non-halting when D(D) is
admitted to be Halting proves you to be a LIAR.

On 3/15/2024 2:19 PM, Richard Damon wrote:
> On 3/15/24 12:06 PM, olcott wrote:
>> 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).
>>
>>
>
> WHich I assumed as a possibility and refuted.
>
> H(D,D) == 0 can't be the correct answer for a Halting Decider as D(D)
> Halts, so the correct answer would be 1.
>

*That is the strawman deception to the title of this thread*

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.

--
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 12:10 PM, olcott wrote:
> 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.

Right, but EVERY H(D,D) aborts so your condition isn't satified and your
arguement is unsound, just like most of your statments.

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

But since the outermost one DOES, so do all the others. Again, your
arguement is based on unsound logic.

The question is not about what answer should H give to answer about an
input defined to be built on the H^ template of itself.

The question is about what is the behavior of computiaton defined by the
machine built on a particular H that just happens to be this one being
asked.

That difference is important, as it means that thought of changing H
don't change the input.

If you deny that this IS the question being asked, then you are
admitting that this whole sideline has been about a strawman and
irreleent to that actual question you are looking to answer.

On 3/15/24 12:03 PM, olcott wrote:
> 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.

And thus you look at a strawman. A case where H isn't the H that we
started with.

If you change the H used by D, you change the quesition being asked.

>
>> 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 3/15/24 12:14 PM, olcott wrote:
> On 3/15/2024 2:06 PM, Richard Damon wrote:
>> 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
>
> never begin to be simulated.

But D(D) started to be simulated, and we can know what D(D) actually
does, which includes it using its version of H.

>
>> do, so THIS algorithm for H doesn't NEED to, but does.
>>
>
> H(D,D) cannot simply wait for another instance of itself to do something
> otherwise all instances of H are waiting on the next one.

Right, because the H that is defined that gets the answer doesn't do that.

Your problem is you think when we are asking the question that somehow H
is a variable, when it is a stipulated constant, used to generate the
stipulated D.

>
>> 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 2:20 PM, Richard Damon wrote:
> On 3/15/24 11:37 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,
>>
>> 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.
>>
>
> Nope, explained many times recently.
>

(a) H(D,D) sees at least one execution trace more than any
nested simulations of itself could possibly see.

(b) Any nested simulations of H(D,D) must have the exact
same behavior as H because they are the exact same code.

Therefore if H(D,D) does not abort its simulation as soon
as its sees that its abort criteria has been met (or some
other fixed limit) then none of the simulated instances of
itself can possibly abort their own simulation.

> You are now just blantently lying, since you obviously don't have a
> valid reason to refute the errors pointed out.

--
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 2:30 PM, Richard Damon wrote:
> On 3/15/24 12:14 PM, olcott wrote:
>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>> 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
>>
>> never begin to be simulated.
>
> But D(D) started to be simulated, and we can know what D(D) actually
> does, which includes it using its version of H.
>

We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this 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 2:28 PM, Richard Damon wrote:
> On 3/15/24 12:03 PM, olcott wrote:
>> 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.
>
> And thus you look at a strawman. A case where H isn't the H that we
> started with.
>
> If you change the H used by D, you change the quesition being asked.
>

We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this 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 2:27 PM, Richard Damon wrote:
> On 3/15/24 12:10 PM, olcott wrote:
>> 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.
>
> Right, but EVERY H(D,D) aborts so your condition isn't satified and your
> arguement is unsound, just like most of your statments.

We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this H(D,D).

H(D,D)==0 is correct meaning that the abort criteria has been met.

--
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: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.

So, you are admititng that H didn't meet (a)?

or are you saying that somehow H can correctly decide on something and
still get the wrong answer?

or, are you admitting that your logic is built on a strawman?

How can you claim that H is a correct HALT DECIDER when it says a
halting computation is non-halting.

You are just proving yourself to be a liar, trying to hide their lies be
deceptively (and incorrectly) trying to redefine words.

As long as you call H a "Halt Decider" it is bound by the actual
definition of a Halt Decider, and you lie when you say an incorrect
answer is correct.

You fail to point out any errors in the rebuttal to you, so this is
taken as an admission that you know you are wrong, and thus by repeating
your lies, they are deliberate deceptions, and not an attempt at honest
dialog.

>
>> 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 12:25 PM, olcott wrote:
> On 3/15/2024 2:19 PM, Richard Damon wrote:
>> On 3/15/24 12:06 PM, olcott wrote:
>>> 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).
>>>
>>>
>>
>> WHich I assumed as a possibility and refuted.
>>
>> H(D,D) == 0 can't be the correct answer for a Halting Decider as D(D)
>> Halts, so the correct answer would be 1.
>>
>
> *That is the strawman deception to the title of this thread*

But your title is refering to your own strawman.

>
> 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.
>

Which PROVES that you are actually refering to Turing Equivalents, and
thus my interpreation as refering to Turing Equivalents is actuall "on
topic" and your own diverstion of a strawman.

You CAN'T keep refering to the Linz proof and Turing Machines and at the
same time claim you are not bound by the equivalence.

On 3/15/2024 2:49 PM, Richard Damon wrote:
> On 3/15/24 12:25 PM, olcott wrote:
>> On 3/15/2024 2:19 PM, Richard Damon wrote:
>>> On 3/15/24 12:06 PM, olcott wrote:
>>>> 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).
>>>>
>>>>
>>>
>>> WHich I assumed as a possibility and refuted.
>>>
>>> H(D,D) == 0 can't be the correct answer for a Halting Decider as D(D)
>>> Halts, so the correct answer would be 1.
>>>
>>
>> *That is the strawman deception to the title of this thread*
>
> But your title is refering to your own strawman.

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.

Not at all. This thread is all about whether or not H(D,D) meets
its abort 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/2024 2:46 PM, Richard Damon wrote:
> 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.
>
> So, you are admititng that H didn't meet (a)?
>
> or are you saying that somehow H can correctly decide on something and
> still get the wrong answer?
>

To the best of my current knowledge you cannot possibly show
that H(D,D) does not meet its abort criteria.

To the best of my current knowledge every attempt at rebuttal
on your part was anchored in counter-factual assumptions.

--
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 2:22 PM, Richard Damon wrote:
> On 3/15/24 12:04 PM, olcott wrote:
>> 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.
>>
>
>
> The fact that H(D,D) returns 0, saying D(D) is non-halting when D(D) is
> admitted to be Halting proves you to be a LIAR.

No. What you said proves that you have a hard time staying
focused on the actual title of this thread.

--
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 12:53 PM, olcott wrote:
> On 3/15/2024 2:49 PM, Richard Damon wrote:
>> On 3/15/24 12:25 PM, olcott wrote:
>>> On 3/15/2024 2:19 PM, Richard Damon wrote:
>>>> On 3/15/24 12:06 PM, olcott wrote:
>>>>> 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).
>>>>>
>>>>>
>>>>
>>>> WHich I assumed as a possibility and refuted.
>>>>
>>>> H(D,D) == 0 can't be the correct answer for a Halting Decider as
>>>> D(D) Halts, so the correct answer would be 1.
>>>>
>>>
>>> *That is the strawman deception to the title of this thread*
>>
>> But your title is refering to your own strawman.
>
> 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.
>
> Not at all. This thread is all about whether or not H(D,D) meets
> its abort criteria.
>

Which, because you ask Profeser Sipser, about Turing Machine
equivalents, and thus H must be interpreted as such, so the H called by
D is a seperate entity to the H deciding on D.

On 3/15/24 12:56 PM, olcott wrote:
> On 3/15/2024 2:46 PM, Richard Damon wrote:
>> 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.
>>
>> So, you are admititng that H didn't meet (a)?
>>
>> or are you saying that somehow H can correctly decide on something and
>> still get the wrong answer?
>>
>
> To the best of my current knowledge you cannot possibly show
> that H(D,D) does not meet its abort criteria.

Which doesn't say much.

What is WRONG with my analysis. If you can't find an error, you need to
admit to yourself that I HAVE shown you wrong.

>
> To the best of my current knowledge every attempt at rebuttal
> on your part was anchored in counter-factual assumptions.
>

Then show the ACTUAL counter-factual assemption.

Point to the ACTUAL ASSUMPTION, and state why it is counter factual.

Not liking my conclusion is NOT a valid arguement.

You just don't understand what makes a logical argument, which doesn't
say much for you concept of "Correct Reasoning" if you can't actually
reason correctly.

On 3/15/2024 2:21 PM, Richard Damon wrote:
> On 3/15/24 11:38 AM, olcott wrote:
>> 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.
>>
>
>
> Nope, Error pointed out many times recently, so you are just admitting
> to being a blantant liar, or utterly incompetent.

To the best of my current knowledge all of your rebuttals
to this relied on counter-factual assumptions that cannot
possibly be supported with correct reasoning because they
are counter-factual.

--
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 12:32 PM, olcott wrote:
> On 3/15/2024 2:20 PM, Richard Damon wrote:
>> On 3/15/24 11:37 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,
>>>
>>> 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.
>>>
>>
>> Nope, explained many times recently.
>>
>
> (a) H(D,D) sees at least one execution trace more than any
> nested simulations of itself could possibly see.

Nope.

Based on the FALSE idea that the actual behavior of the simulated
machine ends when the simulation of it stops.

EVERY copy of H(D,D) sees EXACTLY the same information when IT comes to
its decision point.

Your misunderstanding here just show a fatal lack of understanding of
how computation work.

>
> (b) Any nested simulations of H(D,D) must have the exact
> same behavior as H because they are the exact same code.

Right. DEFINED as the H that you finally decide will be giving the right
answer.

If you hypotosize an alternate H to test out ideas, then D doesn't
change to match that hypotosize until you change your mind and want that
other H to be your final H that gives the right answer.

D is NOT defined to use whatever H is currently trying to decide it, but
only the H that is defined to be the one to give the final answer.

Any other setup make you reference to Linz a LIE.

>
> Therefore if H(D,D) does not abort its simulation as soon
> as its sees that its abort criteria has been met (or some
> other fixed limit) then none of the simulated instances of
> itself can possibly abort their own simulation.

Except if you CHANGE H, then you change the question, and invalidate
your work.

The question is about the H^ (or D) built on the H that you finally
decide to call your Halt Decider.

With THAT H^, it is clear that if you have defined H to abort, as needed
so H gives some answer, that it didn't NEED to abort to reach the final
state of THIS input, as shown by your H1 doing such a simulation.

It is a LIE to look at the simulation of an H^ built on ANY H that isn't
that final one, and unsound logic to use those behaviors claiming they
are the behavior of THIS input.

>
>
>> You are now just blantently lying, since you obviously don't have a
>> valid reason to refute the errors pointed out.
>

On 3/15/24 1:06 PM, olcott wrote:
> On 3/15/2024 2:22 PM, Richard Damon wrote:
>> On 3/15/24 12:04 PM, olcott wrote:
>>> 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.
>>>
>>
>>
>> The fact that H(D,D) returns 0, saying D(D) is non-halting when D(D)
>> is admitted to be Halting proves you to be a LIAR.
>
> No. What you said proves that you have a hard time staying
> focused on the actual title of this thread.
>

So, is it a LIE that you are working on the halting problem, and thus
correct answers are determined by its criteria?

Or, are you LYING about something else?

You claim H is based on your question to Prof. Sipser, and thus H and D
are to be interpreted in the context of Turing Equivalent Computations,
and H by the definition of a Halt Decider.

Thus H(D,D) saying 0 when D(D) Halts is NOT CORRECT, and any criteria
that says it is correct is proven to be UNSOUND.

On 3/15/24 12:42 PM, olcott wrote:
> On 3/15/2024 2:27 PM, Richard Damon wrote:
>> On 3/15/24 12:10 PM, olcott wrote:
>>> 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.
>>
>> Right, but EVERY H(D,D) aborts so your condition isn't satified and
>> your arguement is unsound, just like most of your statments.
>
> We cannot reference the behavior of what D(D) does after H(D,D)
> has already aborted the simulation of its input at the point
> in time before H(D,D) aborts its input as any criterion measure
> for this H(D,D).
>
> H(D,D)==0 is correct meaning that the abort criteria has been met.
>

Why can we not refenerence the behavior of what D(D) does after H(D,D)
aborts it?

Are you admitting to lying about working on the Halting Problem?

As the Halting Problem is about what the Machine Decribed does, and that
continues after its simulation is aborted!

After all, the "Correct Simulation" refered to in (a) would refer to the
behavior after the aborting, since that is the only applicable
definition of "Correct Simulation".

You seem to have some fundametal misconceptions about Computation
Theory, causing you to make all sorts of Errors, and making you a LIAR
when you fail to learn from the mistakes that are pointed out to you.

On 3/15/2024 3:06 PM, Richard Damon wrote:
> On 3/15/24 12:53 PM, olcott wrote:
>> On 3/15/2024 2:49 PM, Richard Damon wrote:
>>> On 3/15/24 12:25 PM, olcott wrote:
>>>> On 3/15/2024 2:19 PM, Richard Damon wrote:
>>>>> On 3/15/24 12:06 PM, olcott wrote:
>>>>>> 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).
>>>>>>
>>>>>>
>>>>>
>>>>> WHich I assumed as a possibility and refuted.
>>>>>
>>>>> H(D,D) == 0 can't be the correct answer for a Halting Decider as
>>>>> D(D) Halts, so the correct answer would be 1.
>>>>>
>>>>
>>>> *That is the strawman deception to the title of this thread*
>>>
>>> But your title is refering to your own strawman.
>>
>> 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.
>>
>> Not at all. This thread is all about whether or not H(D,D) meets
>> its abort criteria.
>>
>
> Which, because you ask Profeser Sipser, about Turing Machine
> equivalents,