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

<snip>

On 3/15/2024 3:43 PM, Richard Damon wrote:
> On 3/15/24 1:37 PM, olcott wrote:
>>
>> It is a fact that the behavior of D(D) after it aborts
>> its simulation cannot be used as abort status criteria or
>> no H(D,D) would ever abort its simulation.
>>
>
> Yes, that is a correct computational argument, but doesn't prove the
> criteria used is correct.
>

>>
>> (a) If simulating halt decider H correctly simulates its input D until H
>> correctly determines that its simulated D would never stop running
>> unless aborted then
>>
>> It seems like you are agreeing with me that H(D,D)==0
>> is correct for the above criteria.
>>
>
> Nope.
>
> It may be the best it can do, but since D(D) halts, then the CORRECT
> SIMULATION of D(D) will reach and end...

*That statement entails this one*

You are saying that H(D,D) is incorrect to abort its simulation
because it does not need to do this after it has already aborted
its simulation. *Thus disagreeing with yourself as quoted above*

--
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 7:18 PM, olcott wrote:
> On 3/15/2024 8:22 PM, Richard Damon wrote:
>> On 3/15/24 5:49 PM, olcott wrote:
>>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>>> On 15/03/2024 18:45, 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, 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.
>>>>
>>>> Correct - but PO has the wrong understanding of "prevent".
>>>>
>>>> Correct understanding:  We're discussing a (putative) HD H examining
>>>> an input (P,I) representing some /fixed/ computation.  When we talk
>>>> about "preventing" H from doing xxxxx (such as aborting a
>>>> simulation) we mean how an amended version H2 (like H but without
>>>> xxxxx) behaves in examining that /same input/ (P,I).
>>>>
>>>
>>> *It can be construed that way, yet that is not it*
>>> In software engineering the above is simply a pair of distinct
>>> execution paths based on a conditional test within the same program.
>>> In both cases D is simply a fixed constant string of machine-code bytes.
>>
>> Right D is a FIXED constant string, and thus the meaning doesn't
>> change if we hypothsize about changing an H.
>>
> It always calls whatever H is at the fixed machine address
> that is encoded within D.

In other words, it has NOTHING to do with Turing Machines, and thus has
NO application to the Linz proof, and you are admitting you are LYING
about it having application.

As D isn't a "Computation" as it takes a "hidden input", namely thely
the contents of them memory now called "H". (It isn't PART OF D, and
isn't a declared parameter to D, so it is a "Hidden Input"

>
> This means that it DOES call H(D,D) in recursive simulation and
> DOES NOT call H1(D,D) in recursive simulation.
>

And means you have been LYING that it has ANYTHING to do with the
HALTING PROBLEM

> Thus H(D,D) must account for this difference and H1(D,D) can
> ignore this difference.
>
>>>
>>> When we use categorically exhaustive reasoning instead of locking
>>> ourselves into the pathological thinking of Richard where H tries
>>> to second guess itself such that anything that H(D,D) does can somehow
>>> be construed as incorrect...
>>
>> Sounds like buzzwords.
>>
>> H doesn't try to second guess, H does what H does. PERIOD. That is all
>> it can do.
>>
>> You don't seem to understand how programs work.
>>
>>>
>>> We as humans analyze everything that every encoding of H can possibly
>>> do and find that categorically every H that never aborts its simulation
>>> results in D(D) never halting.
>>
>> Right. But that doesn't mean that any of the H that DO abort is correct
>
> It means that every H(D,D) that correctly determines by a partial
> simulation of its input: "H correctly simulates its input D until"
> that "D would never stop running unless aborted" that this H(D,D)
> <is> necessarily correct.

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

>
>>>
>>> (a) If simulating halt decider H correctly simulates its input D until H
>>> correctly determines that its simulated D would never stop running
>>> unless aborted then
>>>
>>> It seems like you are agreeing with me that H(D,D)==0
>>> is correct for the above criteria.
>>>
>>
>> Nope.
>>
>> It may be the best it can do, but since D(D) halts, then the CORRECT
>> SIMULATION of D(D) will reach and end...
>
> *That statement entails this one*
>
> You are saying that H(D,D) is incorrect to abort its simulation
> because it does not need to do this after it has already aborted
> its simulation. *Thus disagreeing with yourself as quoted above*
>

Nope, do you even understand what I said?

I think I used too many words you don't understand.

"It is a correct computation argument", as in that is the only thing H
can do as a program, but that doesn't make it correct. There is no way
to write a computation that uses information it never gets.

"But doesn't prove the criteria used is correct": Just because that is
all it can do, doesn't mean it allows H to get the right answer. Thus, H
needing to abort at this point, doesn'r prove the input is non-halting,
(since putting in the abort changed the behavior we saw in the input).

You are just showing your utter stupidity.

On 15/03/24 20:03, 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.
Because every H has the exact same code, every H aborts.

If you change the code, you changed the code so of course the correct
answer will be different. If you force the outer H to not abort, without
changing the code of every H (for example you jump over the abort
decision in the debugger) you will see that the simulated H aborts and
halts normally.

>
>> 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/2024 9:47 PM, Richard Damon wrote:
> On 3/15/24 7:18 PM, olcott wrote:
>> On 3/15/2024 8:22 PM, Richard Damon wrote:
>>> On 3/15/24 5:49 PM, olcott wrote:
>>>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>>>> On 15/03/2024 18:45, 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, 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.
>>>>>
>>>>> Correct - but PO has the wrong understanding of "prevent".
>>>>>
>>>>> Correct understanding:  We're discussing a (putative) HD H
>>>>> examining an input (P,I) representing some /fixed/ computation.
>>>>> When we talk about "preventing" H from doing xxxxx (such as
>>>>> aborting a simulation) we mean how an amended version H2 (like H
>>>>> but without xxxxx) behaves in examining that /same input/ (P,I).
>>>>>
>>>>
>>>> *It can be construed that way, yet that is not it*
>>>> In software engineering the above is simply a pair of distinct
>>>> execution paths based on a conditional test within the same program.
>>>> In both cases D is simply a fixed constant string of machine-code
>>>> bytes.
>>>
>>> Right D is a FIXED constant string, and thus the meaning doesn't
>>> change if we hypothsize about changing an H.
>>>
>> It always calls whatever H is at the fixed machine address
>> that is encoded within D.
>
> In other words, it has NOTHING to do with Turing Machines, and thus has
> NO application to the Linz proof, and you are admitting you are LYING
> about it having application.
>
> As D isn't a "Computation" as it takes a "hidden input", namely thely
> the contents of them memory now called "H". (It isn't PART OF D, and
> isn't a declared parameter to D, so it is a "Hidden Input"
>

On 3/15/24 8:00 PM, olcott wrote:
> On 3/15/2024 9:47 PM, Richard Damon wrote:
>> On 3/15/24 7:18 PM, olcott wrote:
>>> On 3/15/2024 8:22 PM, Richard Damon wrote:
>>>> On 3/15/24 5:49 PM, olcott wrote:
>>>>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>>>>> On 15/03/2024 18:45, 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, 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.
>>>>>>
>>>>>> Correct - but PO has the wrong understanding of "prevent".
>>>>>>
>>>>>> Correct understanding:  We're discussing a (putative) HD H
>>>>>> examining an input (P,I) representing some /fixed/ computation.
>>>>>> When we talk about "preventing" H from doing xxxxx (such as
>>>>>> aborting a simulation) we mean how an amended version H2 (like H
>>>>>> but without xxxxx) behaves in examining that /same input/ (P,I).
>>>>>>
>>>>>
>>>>> *It can be construed that way, yet that is not it*
>>>>> In software engineering the above is simply a pair of distinct
>>>>> execution paths based on a conditional test within the same program.
>>>>> In both cases D is simply a fixed constant string of machine-code
>>>>> bytes.
>>>>
>>>> Right D is a FIXED constant string, and thus the meaning doesn't
>>>> change if we hypothsize about changing an H.
>>>>
>>> It always calls whatever H is at the fixed machine address
>>> that is encoded within D.
>>
>> In other words, it has NOTHING to do with Turing Machines, and thus
>> has NO application to the Linz proof, and you are admitting you are
>> LYING about it having application.
>>
>> As D isn't a "Computation" as it takes a "hidden input", namely thely
>> the contents of them memory now called "H". (It isn't PART OF D, and
>> isn't a declared parameter to D, so it is a "Hidden Input"
>>
>
> I told you that you will not have the basis (prerequisite knowledge)
> to see how this is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩ until after you see how
> H(D,D) does correctly determine that it must abort its simulation.
>
>>>
>>> This means that it DOES call H(D,D) in recursive simulation and
>>> DOES NOT call H1(D,D) in recursive simulation.
>>>
>>
>> And means you have been LYING that it has ANYTHING to do with the
>> HALTING PROBLEM
>>
>>> Thus H(D,D) must account for this difference and H1(D,D) can
>>> ignore this difference.
>>>
>>>>>
>>>>> When we use categorically exhaustive reasoning instead of locking
>>>>> ourselves into the pathological thinking of Richard where H tries
>>>>> to second guess itself such that anything that H(D,D) does can somehow
>>>>> be construed as incorrect...
>>>>
>>>> Sounds like buzzwords.
>>>>
>>>> H doesn't try to second guess, H does what H does. PERIOD. That is
>>>> all it can do.
>>>>
>>>> You don't seem to understand how programs work.
>>>>
>>>>>
>>>>> We as humans analyze everything that every encoding of H can possibly
>>>>> do and find that categorically every H that never aborts its
>>>>> simulation
>>>>> results in D(D) never halting.
>>>>
>>>> Right. But that doesn't mean that any of the H that DO abort is correct
>>>
>>> It means that every H(D,D) that correctly determines by a partial
>>> simulation of its input: "H correctly simulates its input D until"
>>> that "D would never stop running unless aborted" that this H(D,D)
>>> <is> necessarily correct.
>>
>> But means you haven't said ANYTHING about Turing Machines or the
>> actual Halting Problem.
>>
>>>
>>>> saying non-halting as it now is looking at a TOTALLY new set of input.
>>>>
>>>> You don't seem very "Exhaustive" in your reasoning.
>>>>
>>>
>>> // The categorically exhaustive part
>>> For every H(D,D) of the infinite set of encodings of H
>>> that simulate their input
>>>
>>> *no D(D) ever stops running unless aborted by H*
>>
>> But now, your question isn't the Halting Question, since D isn't
>> actually a comptation anymore, as it has a hidden input.
>>
>
> I told you that you will not have the basis (prerequisite knowledge)
> to see how this is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩ until after you see how
> H(D,D) does correctly determine that it must abort its simulation.

On 15/03/24 20:42, olcott wrote:
> 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).

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

**"would never stop running unless aborted* references the behavior of
what D(D) does after H(D,D) has already aborted the simulation of its
input**

On 3/15/2024 6:26 PM, Richard Damon wrote:
> On 3/15/24 3:41 PM, olcott wrote:
>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>> On 3/15/24 2:13 PM, olcott wrote:
>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>> 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).
>>>>>>
>>>>>
>>>>> WHy not?
>>>>>
>>>>> That is what Correct Simulation refers to.
>>>>>
>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>
>>>> *I am not a liar or stupid and you admitted your mistake*
>>>> *I am not a liar or stupid and you admitted your mistake*
>>>> *I am not a liar or stupid and you admitted your mistake*
>>>> *I am not a liar or stupid and you admitted your mistake*
>>>
>>> So, do you admit that the definition of a "Correct Simulation" for
>>> the purposes of that criteria are the complete not-aborted simulation
>>> done by possibly some other simulator?
>>>
>>
>> (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
>>
>> Not at all the words don't say anything like that.
>> "H correctly simulates its input D until"
>> specifically means a partial simulation.
>>
>
> Means H uses a partial simulation to make its decision.
>

On 15/03/24 21:37, olcott wrote:
> On 3/15/2024 3:24 PM, Richard Damon wrote:
>> Why can we not refenerence the behavior of what D(D) does after H(D,D)
>> aborts it?
>>
>
> It is a fact that the behavior of D(D) after it aborts
> its simulation cannot be used as abort status criteria or
> no H(D,D) would ever abort its simulation.
>

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

On 16/03/24 01:49, olcott wrote:
> On 3/15/2024 6:37 PM, Mike Terry wrote:
>> Correct - but PO has the wrong understanding of "prevent".
>>
>> Correct understanding:  We're discussing a (putative) HD H examining
>> an input (P,I) representing some /fixed/ computation.  When we talk
>> about "preventing" H from doing xxxxx (such as aborting a simulation)
>> we mean how an amended version H2 (like H but without xxxxx) behaves
>> in examining that /same input/ (P,I).
>>
>
> *It can be construed that way, yet that is not it*

Why did you dishonestly ignore the rest of Mike's post?

>
>> PO understanding:  When PO reads "prevent H from doing xxxxx" he
>> thinks we change the C code of H to H' (which /in PO's x86utm/ system
>> entails also changing D to D'), and then restart everything so we are
>> looking at H' deciding (D',D') - a totally different input.  He then
>> notes that D'(D') doesn't halt, so concludes (outer) H is right to
>> decide non-halting on the ground that D'(D') runs forever. Same PO
>> thinking applies to all his duffer "conditionals" in his phrases like
>> "what H /would/ do...", and "halts /only/ because...".
>>
>> Things that reinforce PO's wrong thinking:
>> -  His x86utm.exe design confuses the distinction between code and data.
>>     H and D are both CODE (like TMs) when called from main(), but when
>> passed as
>>     parameters to H or D, and when simulated, they are logically DATA.
>>     Perhaps if PO had designed x86utm "properly" and not confused
>> these notions
>>     in his x86utm design, he would have realised that discussing
>> alternative H
>>     behaviours was purely a CODE matter, and the input (P,I), being
>> DATA, does not
>>     magically change as a result of any H coding change...
>> -  Since PO does not physically embed H logic into C function D() ,
>> and instead just
>>     calls H, PO probably fails to consider that changing H is also
>> changing D.  Also
>>     the fact that as parameters in halt7.c they appear just as "H" and
>> "D" obscuring the
>>     fact that D is not just the code in D but also includes all the H
>> code.
>>
>> With PO's choices for x86utm design, we can't just simply evaluate
>> PO's duffer conditionals by updating H, recompiling and rerunning
>> [since that would be changing code AND INPUT DATA].  A couple of ways
>> to do it "properly" within PO's current design:
>> -  keep H and D unchanged, but implement the updated H as H2.  Then we
>> can examine H2(D,D),
>>     while the input (D,D) being examined is not changed.  As with PO's
>> H1(D,D), H2 will see
>>     the simulated D(D) terminate.
>> -  Examine H(D,D) (no code changes) but under a debugger.  When
>> [outer] H goes to abort,
>>     use the debugger to jump H over the abort and let things continue.
>>     That's a bit fiddly, as the program being debugged is x86utm, not
>> H, but I gave it a
>>     go to settle this argument once and for all.  :)  As we all would
>> expect,
>>     H goes on to examine the full D(D) simulation instead of aborting,
>> AND OBSERVES
>>     THAT D(D) HALTS.
>>     So now it's confirmed!  What H "would" do if it didn't abort its
>> simulation of D(D)
>>     is "continue simulating until it see D(D) halt".  So H has not
>> "correctly seen
>>     that its input would not halt unless aborted".  (PO won't
>> understand though.)
>>
>>
>> Mike.
>>
>

On 16/03/24 03:18, olcott wrote:
> It means that every H(D,D) that correctly determines by a partial
> simulation of its input: "H correctly simulates its input D until"
> that "D would never stop running unless aborted" that this H(D,D)
> <is> necessarily correct.

And what does that mean?
>
>> saying non-halting as it now is looking at a TOTALLY new set of input.
>>
>> You don't seem very "Exhaustive" in your reasoning.
>>
>
> // The categorically exhaustive part
> For every H(D,D) of the infinite set of encodings of H
> that simulate their input

And what does that mean?

>
> *no D(D) ever stops running unless aborted by H*

On 3/15/24 8:14 PM, olcott wrote:
> On 3/15/2024 6:26 PM, Richard Damon wrote:
>> On 3/15/24 3:41 PM, olcott wrote:
>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>> 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).
>>>>>>>
>>>>>>
>>>>>> WHy not?
>>>>>>
>>>>>> That is what Correct Simulation refers to.
>>>>>>
>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>
>>>> So, do you admit that the definition of a "Correct Simulation" for
>>>> the purposes of that criteria are the complete not-aborted
>>>> simulation done by possibly some other simulator?
>>>>
>>>
>>> (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
>>>
>>> Not at all the words don't say anything like that.
>>> "H correctly simulates its input D until"
>>> specifically means a partial simulation.
>>>
>>
>> Means H uses a partial simulation to make its decision.
>>
>
> Finally you get this.
>
>> The correctness of the decision is measured by the full simulation,
>> even past where H simulated. Thus, is based on things H might not know.
>>
>
> No. the correctness of the decision is essentially anchored
> in something like mathematical induction that correctly
> predicts that complete simulation would never end.

On 3/15/2024 10:17 PM, immibis wrote:
> On 16/03/24 03:18, olcott wrote:
>> It means that every H(D,D) that correctly determines by a partial
>> simulation of its input: "H correctly simulates its input D until"
>> that "D would never stop running unless aborted" that this H(D,D)
>> <is> necessarily correct.
>
> And what does that mean?
>>
>>> saying non-halting as it now is looking at a TOTALLY new set of input.
>>>
>>> You don't seem very "Exhaustive" in your reasoning.
>>>
>>
>> // The categorically exhaustive part
>> For every H(D,D) of the infinite set of encodings of H
>> that simulate their input
>
> And what does that mean?
>
I am trying to make my words as clear as possible so reviews
like this one are very helpful.

There cannot possibly exist any H(D,D) that is called by
D where H(D,D) simulates its input and D(D) stops running
and H never aborts its simulation.

> >
> > *no D(D) ever stops running unless aborted by H*

--
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 10:16 PM, immibis wrote:
> On 16/03/24 01:49, olcott wrote:
>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>> Correct - but PO has the wrong understanding of "prevent".
>>>
>>> Correct understanding:  We're discussing a (putative) HD H examining
>>> an input (P,I) representing some /fixed/ computation.  When we talk
>>> about "preventing" H from doing xxxxx (such as aborting a simulation)
>>> we mean how an amended version H2 (like H but without xxxxx) behaves
>>> in examining that /same input/ (P,I).
>>>
>>
>> *It can be construed that way, yet that is not it*
>
> Why did you dishonestly ignore the rest of Mike's post?
>

Because I had already disavowed the rest of Mike's post.
Mike's post may have been correct computer science yet
his words failed to understand this simple truth:

*These words are much easier to understand*
There cannot possibly exist any H(D,D) that is called by
D where H(D,D) simulates its input and D(D) stops running
and H never aborts its simulation.

>>
>>> PO understanding:  When PO reads "prevent H from doing xxxxx" he
>>> thinks we change the C code of H to H' (which /in PO's x86utm/ system
>>> entails also changing D to D'), and then restart everything so we are
>>> looking at H' deciding (D',D') - a totally different input.  He then
>>> notes that D'(D') doesn't halt, so concludes (outer) H is right to
>>> decide non-halting on the ground that D'(D') runs forever. Same PO
>>> thinking applies to all his duffer "conditionals" in his phrases like
>>> "what H /would/ do...", and "halts /only/ because...".
>>>
>>> Things that reinforce PO's wrong thinking:
>>> -  His x86utm.exe design confuses the distinction between code and data.
>>>     H and D are both CODE (like TMs) when called from main(), but
>>> when passed as
>>>     parameters to H or D, and when simulated, they are logically DATA.
>>>     Perhaps if PO had designed x86utm "properly" and not confused
>>> these notions
>>>     in his x86utm design, he would have realised that discussing
>>> alternative H
>>>     behaviours was purely a CODE matter, and the input (P,I), being
>>> DATA, does not
>>>     magically change as a result of any H coding change...
>>> -  Since PO does not physically embed H logic into C function D() ,
>>> and instead just
>>>     calls H, PO probably fails to consider that changing H is also
>>> changing D.  Also
>>>     the fact that as parameters in halt7.c they appear just as "H"
>>> and "D" obscuring the
>>>     fact that D is not just the code in D but also includes all the H
>>> code.
>>>
>>> With PO's choices for x86utm design, we can't just simply evaluate
>>> PO's duffer conditionals by updating H, recompiling and rerunning
>>> [since that would be changing code AND INPUT DATA].  A couple of ways
>>> to do it "properly" within PO's current design:
>>> -  keep H and D unchanged, but implement the updated H as H2.  Then
>>> we can examine H2(D,D),
>>>     while the input (D,D) being examined is not changed.  As with
>>> PO's H1(D,D), H2 will see
>>>     the simulated D(D) terminate.
>>> -  Examine H(D,D) (no code changes) but under a debugger.  When
>>> [outer] H goes to abort,
>>>     use the debugger to jump H over the abort and let things continue.
>>>     That's a bit fiddly, as the program being debugged is x86utm, not
>>> H, but I gave it a
>>>     go to settle this argument once and for all.  :)  As we all would
>>> expect,
>>>     H goes on to examine the full D(D) simulation instead of
>>> aborting, AND OBSERVES
>>>     THAT D(D) HALTS.
>>>     So now it's confirmed!  What H "would" do if it didn't abort its
>>> simulation of D(D)
>>>     is "continue simulating until it see D(D) halt".  So H has not
>>> "correctly seen
>>>     that its input would not halt unless aborted".  (PO won't
>>> understand though.)
>>>
>>>
>>> Mike.
>>>
>>
>

--
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 10:11 PM, Richard Damon wrote:
> On 3/15/24 8:00 PM, olcott wrote:
>> On 3/15/2024 9:47 PM, Richard Damon wrote:
>>> On 3/15/24 7:18 PM, olcott wrote:
>>>> On 3/15/2024 8:22 PM, Richard Damon wrote:
>>>>> On 3/15/24 5:49 PM, olcott wrote:
>>>>>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>>>>>> On 15/03/2024 18:45, 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, 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.
>>>>>>>
>>>>>>> Correct - but PO has the wrong understanding of "prevent".
>>>>>>>
>>>>>>> Correct understanding:  We're discussing a (putative) HD H
>>>>>>> examining an input (P,I) representing some /fixed/ computation.
>>>>>>> When we talk about "preventing" H from doing xxxxx (such as
>>>>>>> aborting a simulation) we mean how an amended version H2 (like H
>>>>>>> but without xxxxx) behaves in examining that /same input/ (P,I).
>>>>>>>
>>>>>>
>>>>>> *It can be construed that way, yet that is not it*
>>>>>> In software engineering the above is simply a pair of distinct
>>>>>> execution paths based on a conditional test within the same program.
>>>>>> In both cases D is simply a fixed constant string of machine-code
>>>>>> bytes.
>>>>>
>>>>> Right D is a FIXED constant string, and thus the meaning doesn't
>>>>> change if we hypothsize about changing an H.
>>>>>
>>>> It always calls whatever H is at the fixed machine address
>>>> that is encoded within D.
>>>
>>> In other words, it has NOTHING to do with Turing Machines, and thus
>>> has NO application to the Linz proof, and you are admitting you are
>>> LYING about it having application.
>>>
>>> As D isn't a "Computation" as it takes a "hidden input", namely thely
>>> the contents of them memory now called "H". (It isn't PART OF D, and
>>> isn't a declared parameter to D, so it is a "Hidden Input"
>>>
>>
>> I told you that you will not have the basis (prerequisite knowledge)
>> to see how this is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩ until after you see how
>> H(D,D) does correctly determine that it must abort its simulation.
>>
>>>>
>>>> This means that it DOES call H(D,D) in recursive simulation and
>>>> DOES NOT call H1(D,D) in recursive simulation.
>>>>
>>>
>>> And means you have been LYING that it has ANYTHING to do with the
>>> HALTING PROBLEM
>>>
>>>> Thus H(D,D) must account for this difference and H1(D,D) can
>>>> ignore this difference.
>>>>
>>>>>>
>>>>>> When we use categorically exhaustive reasoning instead of locking
>>>>>> ourselves into the pathological thinking of Richard where H tries
>>>>>> to second guess itself such that anything that H(D,D) does can
>>>>>> somehow
>>>>>> be construed as incorrect...
>>>>>
>>>>> Sounds like buzzwords.
>>>>>
>>>>> H doesn't try to second guess, H does what H does. PERIOD. That is
>>>>> all it can do.
>>>>>
>>>>> You don't seem to understand how programs work.
>>>>>
>>>>>>
>>>>>> We as humans analyze everything that every encoding of H can possibly
>>>>>> do and find that categorically every H that never aborts its
>>>>>> simulation
>>>>>> results in D(D) never halting.
>>>>>
>>>>> Right. But that doesn't mean that any of the H that DO abort is
>>>>> correct
>>>>
>>>> It means that every H(D,D) that correctly determines by a partial
>>>> simulation of its input: "H correctly simulates its input D until"
>>>> that "D would never stop running unless aborted" that this H(D,D)
>>>> <is> necessarily correct.
>>>
>>> But means you haven't said ANYTHING about Turing Machines or the
>>> actual Halting Problem.
>>>
>>>>
>>>>> saying non-halting as it now is looking at a TOTALLY new set of input.
>>>>>
>>>>> You don't seem very "Exhaustive" in your reasoning.
>>>>>
>>>>
>>>> // The categorically exhaustive part
>>>> For every H(D,D) of the infinite set of encodings of H
>>>> that simulate their input
>>>>
>>>> *no D(D) ever stops running unless aborted by H*
>>>
>>> But now, your question isn't the Halting Question, since D isn't
>>> actually a comptation anymore, as it has a hidden input.
>>>
>>
>> I told you that you will not have the basis (prerequisite knowledge)
>> to see how this is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩ until after you see how
>> H(D,D) does correctly determine that it must abort its simulation.
>
> So, you just admitted that your D CAN'T be isomophic to H^, so you ar
> just lying.
>
>
>
>>
>>>>
>>>> This is how we break out of the double-think of construing
>>>> that no H(D,D) can possibly correctly match the recursive
>>>> simulation non-halting behavior pattern.
>>>>
>>>> https://en.wikipedia.org/wiki/Doublethink
>>>> *>
>>> So you lie again.
>>>
>>> What are the two contradictory ideas?
>>>
>>
>> That no H(D,D) can possibly correctly determine that
>> it must abort its simulation because after it already
>> has aborted its simulation it doesn't need to do this.
>>
>
> So, one thing is two things?
>
> I guess you are dumber that I thought.
>
>>> Your H STILL gets the wrong answer, as D(D) still halts when H(D,D)
>>> says it doesn't.
>>>
>>
>> *We have never been talking about this in this whole thread*
>> *We are only talking about H(D,D) meeting its abort criteria*
>
> But saying your abort criteria is a HALTING criteria.
>
It make have been confusing because I quote all of what professor
Sipser said. I try to stick exactly within the scope of the title
of the post: [Proof that H(D,D) meets its abort criteria] thus I
was only referring to the (a) criteria of the full quote.

On 3/15/2024 10:28 PM, Richard Damon wrote:
> On 3/15/24 8:14 PM, olcott wrote:
>> On 3/15/2024 6:26 PM, Richard Damon wrote:
>>> On 3/15/24 3:41 PM, olcott wrote:
>>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>>> 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).
>>>>>>>>
>>>>>>>
>>>>>>> WHy not?
>>>>>>>
>>>>>>> That is what Correct Simulation refers to.
>>>>>>>
>>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>>
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>
>>>>> So, do you admit that the definition of a "Correct Simulation" for
>>>>> the purposes of that criteria are the complete not-aborted
>>>>> simulation done by possibly some other simulator?
>>>>>
>>>>
>>>> (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
>>>>
>>>> Not at all the words don't say anything like that.
>>>> "H correctly simulates its input D until"
>>>> specifically means a partial simulation.
>>>>
>>>
>>> Means H uses a partial simulation to make its decision.
>>>
>>
>> Finally you get this.
>>
>>> The correctness of the decision is measured by the full simulation,
>>> even past where H simulated. Thus, is based on things H might not know.
>>>
>>
>> No. the correctness of the decision is essentially anchored
>> in something like mathematical induction that correctly
>> predicts that complete simulation would never end.
>
> But, since the Execution DOES end, so will a correct simulation.
>

On 16/03/24 04:14, olcott wrote:
> On 3/15/2024 6:26 PM, Richard Damon wrote:
>> On 3/15/24 3:41 PM, olcott wrote:
>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>> 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).
>>>>>>>
>>>>>>
>>>>>> WHy not?
>>>>>>
>>>>>> That is what Correct Simulation refers to.
>>>>>>
>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>
>>>> So, do you admit that the definition of a "Correct Simulation" for
>>>> the purposes of that criteria are the complete not-aborted
>>>> simulation done by possibly some other simulator?
>>>>
>>>
>>> (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
>>>
>>> Not at all the words don't say anything like that.
>>> "H correctly simulates its input D until"
>>> specifically means a partial simulation.
>>>
>>
>> Means H uses a partial simulation to make its decision.
>>
>
> Finally you get this.
>
>> The correctness of the decision is measured by the full simulation,
>> even past where H simulated. Thus, is based on things H might not know.
>>
>
> No. the correctness of the decision is essentially anchored
> in something like mathematical induction that correctly
> predicts that complete simulation would never end.

On 16/03/24 04:29, olcott wrote:
> On 3/15/2024 10:17 PM, immibis wrote:
>> On 16/03/24 03:18, olcott wrote:
>>> It means that every H(D,D) that correctly determines by a partial
>>> simulation of its input: "H correctly simulates its input D until"
>>> that "D would never stop running unless aborted" that this H(D,D)
>>> <is> necessarily correct.
>>
>> And what does that mean?
>>>
>>>> saying non-halting as it now is looking at a TOTALLY new set of input.
>>>>
>>>> You don't seem very "Exhaustive" in your reasoning.
>>>>
>>>
>>> // The categorically exhaustive part
>>> For every H(D,D) of the infinite set of encodings of H
>>> that simulate their input
>>
>> And what does that mean?
>>
> I am trying to make my words as clear as possible so reviews
> like this one are very helpful.
>
> There cannot possibly exist any H(D,D) that is called by
> D where H(D,D) simulates its input and D(D) stops running
> and H never aborts its simulation.

And what does THAT mean? What is "any H(D,D)"?

I think you are probably using words in a different way than everyone
else so it would be nice to understand your words as well as I
understand Turing machines.

>
>>  >
>>  > *no D(D) ever stops running unless aborted by H*
>

On 16/03/24 04:34, olcott wrote:
> On 3/15/2024 10:16 PM, immibis wrote:
>> On 16/03/24 01:49, olcott wrote:
>>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>>> Correct - but PO has the wrong understanding of "prevent".
>>>>
>>>> Correct understanding:  We're discussing a (putative) HD H examining
>>>> an input (P,I) representing some /fixed/ computation.  When we talk
>>>> about "preventing" H from doing xxxxx (such as aborting a
>>>> simulation) we mean how an amended version H2 (like H but without
>>>> xxxxx) behaves in examining that /same input/ (P,I).
>>>>
>>>
>>> *It can be construed that way, yet that is not it*
>>
>> Why did you dishonestly ignore the rest of Mike's post?
>>
>
> Because I had already disavowed the rest of Mike's post.
> Mike's post may have been correct computer science yet
> his words failed to understand this simple truth:
>
> *These words are much easier to understand*
> There cannot possibly exist any H(D,D) that is called by
> D where H(D,D) simulates its input and D(D) stops running
> and H never aborts its simulation.

I can tell you're ignoring it because I read it and that's how I can tell.

>
>>>
>>>> PO understanding:  When PO reads "prevent H from doing xxxxx" he
>>>> thinks we change the C code of H to H' (which /in PO's x86utm/
>>>> system entails also changing D to D'), and then restart everything
>>>> so we are looking at H' deciding (D',D') - a totally different
>>>> input.  He then notes that D'(D') doesn't halt, so concludes (outer)
>>>> H is right to decide non-halting on the ground that D'(D') runs
>>>> forever. Same PO thinking applies to all his duffer "conditionals"
>>>> in his phrases like "what H /would/ do...", and "halts /only/
>>>> because...".
>>>>
>>>> Things that reinforce PO's wrong thinking:
>>>> -  His x86utm.exe design confuses the distinction between code and
>>>> data.
>>>>     H and D are both CODE (like TMs) when called from main(), but
>>>> when passed as
>>>>     parameters to H or D, and when simulated, they are logically DATA.
>>>>     Perhaps if PO had designed x86utm "properly" and not confused
>>>> these notions
>>>>     in his x86utm design, he would have realised that discussing
>>>> alternative H
>>>>     behaviours was purely a CODE matter, and the input (P,I), being
>>>> DATA, does not
>>>>     magically change as a result of any H coding change...
>>>> -  Since PO does not physically embed H logic into C function D() ,
>>>> and instead just
>>>>     calls H, PO probably fails to consider that changing H is also
>>>> changing D.  Also
>>>>     the fact that as parameters in halt7.c they appear just as "H"
>>>> and "D" obscuring the
>>>>     fact that D is not just the code in D but also includes all the
>>>> H code.
>>>>
>>>> With PO's choices for x86utm design, we can't just simply evaluate
>>>> PO's duffer conditionals by updating H, recompiling and rerunning
>>>> [since that would be changing code AND INPUT DATA].  A couple of
>>>> ways to do it "properly" within PO's current design:
>>>> -  keep H and D unchanged, but implement the updated H as H2.  Then
>>>> we can examine H2(D,D),
>>>>     while the input (D,D) being examined is not changed.  As with
>>>> PO's H1(D,D), H2 will see
>>>>     the simulated D(D) terminate.
>>>> -  Examine H(D,D) (no code changes) but under a debugger.  When
>>>> [outer] H goes to abort,
>>>>     use the debugger to jump H over the abort and let things continue.
>>>>     That's a bit fiddly, as the program being debugged is x86utm,
>>>> not H, but I gave it a
>>>>     go to settle this argument once and for all.  :)  As we all
>>>> would expect,
>>>>     H goes on to examine the full D(D) simulation instead of
>>>> aborting, AND OBSERVES
>>>>     THAT D(D) HALTS.
>>>>     So now it's confirmed!  What H "would" do if it didn't abort its
>>>> simulation of D(D)
>>>>     is "continue simulating until it see D(D) halt".  So H has not
>>>> "correctly seen
>>>>     that its input would not halt unless aborted".  (PO won't
>>>> understand though.)
>>>>
>>>>
>>>> Mike.
>>>>
>>>
>>
>

On 3/15/2024 10:58 PM, immibis wrote:
> On 16/03/24 04:34, olcott wrote:
>> On 3/15/2024 10:16 PM, immibis wrote:
>>> On 16/03/24 01:49, olcott wrote:
>>>> On 3/15/2024 6:37 PM, Mike Terry wrote:
>>>>> Correct - but PO has the wrong understanding of "prevent".
>>>>>
>>>>> Correct understanding:  We're discussing a (putative) HD H
>>>>> examining an input (P,I) representing some /fixed/ computation.
>>>>> When we talk about "preventing" H from doing xxxxx (such as
>>>>> aborting a simulation) we mean how an amended version H2 (like H
>>>>> but without xxxxx) behaves in examining that /same input/ (P,I).
>>>>>

It does not mean anything like that in software engineering,
or even set theory (as shown below). I could see such a view
being construed as correct computer science.

>>>>
>>>> *It can be construed that way, yet that is not it*
>>>
>>> Why did you dishonestly ignore the rest of Mike's post?
>>>
>>
>> Because I had already disavowed the rest of Mike's post.
>> Mike's post may have been correct computer science yet
>> his words failed to understand this simple truth:
>>
>> *These words are much easier to understand*
>> There cannot possibly exist any H(D,D) that is called by
>> D where H(D,D) simulates its input and D(D) stops running
>> and H never aborts its simulation.
>
> I can tell you're ignoring it because I read it and that's how I can tell.
>

I can't understand what you are saying.

>>
>>>>
>>>>> PO understanding:  When PO reads "prevent H from doing xxxxx" he
>>>>> thinks we change the C code of H to H' (which /in PO's x86utm/
>>>>> system entails also changing D to D'), and then restart everything
>>>>> so we are looking at H' deciding (D',D') - a totally different
>>>>> input.  He then notes that D'(D') doesn't halt, so concludes
>>>>> (outer) H is right to decide non-halting on the ground that D'(D')
>>>>> runs forever. Same PO thinking applies to all his duffer
>>>>> "conditionals" in his phrases like "what H /would/ do...", and
>>>>> "halts /only/ because...".
>>>>>
>>>>> Things that reinforce PO's wrong thinking:
>>>>> -  His x86utm.exe design confuses the distinction between code and
>>>>> data.
>>>>>     H and D are both CODE (like TMs) when called from main(), but
>>>>> when passed as
>>>>>     parameters to H or D, and when simulated, they are logically DATA.
>>>>>     Perhaps if PO had designed x86utm "properly" and not confused
>>>>> these notions
>>>>>     in his x86utm design, he would have realised that discussing
>>>>> alternative H
>>>>>     behaviours was purely a CODE matter, and the input (P,I), being
>>>>> DATA, does not
>>>>>     magically change as a result of any H coding change...
>>>>> -  Since PO does not physically embed H logic into C function D() ,
>>>>> and instead just
>>>>>     calls H, PO probably fails to consider that changing H is also
>>>>> changing D.  Also
>>>>>     the fact that as parameters in halt7.c they appear just as "H"
>>>>> and "D" obscuring the
>>>>>     fact that D is not just the code in D but also includes all the
>>>>> H code.
>>>>>
>>>>> With PO's choices for x86utm design, we can't just simply evaluate
>>>>> PO's duffer conditionals by updating H, recompiling and rerunning
>>>>> [since that would be changing code AND INPUT DATA].  A couple of
>>>>> ways to do it "properly" within PO's current design:
>>>>> -  keep H and D unchanged, but implement the updated H as H2.  Then
>>>>> we can examine H2(D,D),
>>>>>     while the input (D,D) being examined is not changed.  As with
>>>>> PO's H1(D,D), H2 will see
>>>>>     the simulated D(D) terminate.
>>>>> -  Examine H(D,D) (no code changes) but under a debugger.  When
>>>>> [outer] H goes to abort,
>>>>>     use the debugger to jump H over the abort and let things continue.
>>>>>     That's a bit fiddly, as the program being debugged is x86utm,
>>>>> not H, but I gave it a
>>>>>     go to settle this argument once and for all.  :)  As we all
>>>>> would expect,
>>>>>     H goes on to examine the full D(D) simulation instead of
>>>>> aborting, AND OBSERVES
>>>>>     THAT D(D) HALTS.
>>>>>     So now it's confirmed!  What H "would" do if it didn't abort
>>>>> its simulation of D(D)
>>>>>     is "continue simulating until it see D(D) halt".  So H has not
>>>>> "correctly seen
>>>>>     that its input would not halt unless aborted".  (PO won't
>>>>> understand though.)
>>>>>
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>
>>
>

--
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 10:57 PM, immibis wrote:
> On 16/03/24 04:29, olcott wrote:
>> On 3/15/2024 10:17 PM, immibis wrote:
>>> On 16/03/24 03:18, olcott wrote:
>>>> It means that every H(D,D) that correctly determines by a partial
>>>> simulation of its input: "H correctly simulates its input D until"
>>>> that "D would never stop running unless aborted" that this H(D,D)
>>>> <is> necessarily correct.
>>>
>>> And what does that mean?
>>>>
>>>>> saying non-halting as it now is looking at a TOTALLY new set of input.
>>>>>
>>>>> You don't seem very "Exhaustive" in your reasoning.
>>>>>
>>>>
>>>> // The categorically exhaustive part
>>>> For every H(D,D) of the infinite set of encodings of H
>>>> that simulate their input
>>>
>>> And what does that mean?
>>>
>> I am trying to make my words as clear as possible so reviews
>> like this one are very helpful.
>>
>> There cannot possibly exist any H(D,D) that is called by
>> D where H(D,D) simulates its input and D(D) stops running
>> and H never aborts its simulation.
>
> And what does THAT mean? What is "any H(D,D)"?
>

*software engineering and set theory*
Every C function named H(D,D) that simulates its input and
D(D) calls H(D,D) never stops running unless aborted by H.

> I think you are probably using words in a different way than everyone
> else so it would be nice to understand your words as well as I
> understand Turing machines.
>
>>
>>>  >
>>>  > *no D(D) ever stops running unless aborted by H*
>>
>

--
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 10:55 PM, immibis wrote:
> On 16/03/24 04:14, olcott wrote:
>> On 3/15/2024 6:26 PM, Richard Damon wrote:
>>> On 3/15/24 3:41 PM, olcott wrote:
>>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>>> 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).
>>>>>>>>
>>>>>>>
>>>>>>> WHy not?
>>>>>>>
>>>>>>> That is what Correct Simulation refers to.
>>>>>>>
>>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>>
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>
>>>>> So, do you admit that the definition of a "Correct Simulation" for
>>>>> the purposes of that criteria are the complete not-aborted
>>>>> simulation done by possibly some other simulator?
>>>>>
>>>>
>>>> (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
>>>>
>>>> Not at all the words don't say anything like that.
>>>> "H correctly simulates its input D until"
>>>> specifically means a partial simulation.
>>>>
>>>
>>> Means H uses a partial simulation to make its decision.
>>>
>>
>> Finally you get this.
>>
>>> The correctness of the decision is measured by the full simulation,
>>> even past where H simulated. Thus, is based on things H might not know.
>>>
>>
>> No. the correctness of the decision is essentially anchored
>> in something like mathematical induction that correctly
>> predicts that complete simulation would never end.
>
> The correctness of the decision is anchored in whether D(D) halts or not.

On 16/03/24 05:15, olcott wrote:
> On 3/15/2024 10:57 PM, immibis wrote:
>> On 16/03/24 04:29, olcott wrote:
>>> On 3/15/2024 10:17 PM, immibis wrote:
>>>> On 16/03/24 03:18, olcott wrote:
>>>>> It means that every H(D,D) that correctly determines by a partial
>>>>> simulation of its input: "H correctly simulates its input D until"
>>>>> that "D would never stop running unless aborted" that this H(D,D)
>>>>> <is> necessarily correct.
>>>>
>>>> And what does that mean?
>>>>>
>>>>>> saying non-halting as it now is looking at a TOTALLY new set of
>>>>>> input.
>>>>>>
>>>>>> You don't seem very "Exhaustive" in your reasoning.
>>>>>>
>>>>>
>>>>> // The categorically exhaustive part
>>>>> For every H(D,D) of the infinite set of encodings of H
>>>>> that simulate their input
>>>>
>>>> And what does that mean?
>>>>
>>> I am trying to make my words as clear as possible so reviews
>>> like this one are very helpful.
>>>
>>> There cannot possibly exist any H(D,D) that is called by
>>> D where H(D,D) simulates its input and D(D) stops running
>>> and H never aborts its simulation.
>>
>> And what does THAT mean? What is "any H(D,D)"?
>>
>
> *software engineering and set theory*
> Every C function named H(D,D) that simulates its input and
> D(D) calls H(D,D) never stops running unless aborted by H.

"D(D) calls H(D,D) never stops running unless aborted by H." seems to be
a nonsensical sentence.

C functions cannot be named H(D,D) because ( , and ) are illegal
characters in C function names.

>> I think you are probably using words in a different way than everyone
>> else so it would be nice to understand your words as well as I
>> understand Turing machines.

On 3/15/24 8:45 PM, olcott wrote:
> On 3/15/2024 10:28 PM, Richard Damon wrote:
>> On 3/15/24 8:14 PM, olcott wrote:
>>> On 3/15/2024 6:26 PM, Richard Damon wrote:
>>>> On 3/15/24 3:41 PM, olcott wrote:
>>>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>>>> 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).
>>>>>>>>>
>>>>>>>>
>>>>>>>> WHy not?
>>>>>>>>
>>>>>>>> That is what Correct Simulation refers to.
>>>>>>>>
>>>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>>>
>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>
>>>>>> So, do you admit that the definition of a "Correct Simulation" for
>>>>>> the purposes of that criteria are the complete not-aborted
>>>>>> simulation done by possibly some other simulator?
>>>>>>
>>>>>
>>>>> (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
>>>>>
>>>>> Not at all the words don't say anything like that.
>>>>> "H correctly simulates its input D until"
>>>>> specifically means a partial simulation.
>>>>>
>>>>
>>>> Means H uses a partial simulation to make its decision.
>>>>
>>>
>>> Finally you get this.
>>>
>>>> The correctness of the decision is measured by the full simulation,
>>>> even past where H simulated. Thus, is based on things H might not know.
>>>>
>>>
>>> No. the correctness of the decision is essentially anchored
>>> in something like mathematical induction that correctly
>>> predicts that complete simulation would never end.
>>
>> But, since the Execution DOES end, so will a correct simulation.
>>
>
> *YOU KEEP FORGETTING THIS*
> There cannot possibly exist any H(D,D) that is called by
> D where H(D,D) simulates its input and D(D) stops running
> and H never aborts its simulation.
>
>> You seem to think that it is possible to prove a false statement.
>>
>>>
>>> I would estimate that an actual proof fully anchored in actual
>>> mathematical induction can be derived. I do remember from my
>>> independent studies course on proof of program correctness that
>>> this does typically anchor in actual mathematical induction.
>>
>> So, you REALLY beleive that you can prove that the correct simulation
>> of a halting computation can go on forever.
>>
>
> There cannot possibly exist any H(D,D) that is called by
> D where H(D,D) simulates its input and D(D) stops running
> and H never aborts its simulation.

On 3/15/2024 11:26 PM, immibis wrote:
> On 16/03/24 05:15, olcott wrote:
>> On 3/15/2024 10:57 PM, immibis wrote:
>>> On 16/03/24 04:29, olcott wrote:
>>>> On 3/15/2024 10:17 PM, immibis wrote:
>>>>> On 16/03/24 03:18, olcott wrote:
>>>>>> It means that every H(D,D) that correctly determines by a partial
>>>>>> simulation of its input: "H correctly simulates its input D until"
>>>>>> that "D would never stop running unless aborted" that this H(D,D)
>>>>>> <is> necessarily correct.
>>>>>
>>>>> And what does that mean?
>>>>>>
>>>>>>> saying non-halting as it now is looking at a TOTALLY new set of
>>>>>>> input.
>>>>>>>
>>>>>>> You don't seem very "Exhaustive" in your reasoning.
>>>>>>>
>>>>>>
>>>>>> // The categorically exhaustive part
>>>>>> For every H(D,D) of the infinite set of encodings of H
>>>>>> that simulate their input
>>>>>
>>>>> And what does that mean?
>>>>>
>>>> I am trying to make my words as clear as possible so reviews
>>>> like this one are very helpful.
>>>>
>>>> There cannot possibly exist any H(D,D) that is called by
>>>> D where H(D,D) simulates its input and D(D) stops running
>>>> and H never aborts its simulation.
>>>
>>> And what does THAT mean? What is "any H(D,D)"?
>>>
>>
>> *software engineering and set theory*
>> Every C function named H(D,D) that simulates its input and
>> D(D) calls H(D,D) never stops running unless aborted by H.
>
> "D(D) calls H(D,D) never stops running unless aborted by H." seems to be
> a nonsensical sentence.
>
> C functions cannot be named H(D,D)

I was using the short-hand of the function call notation.
The full code has be published for years. H begins at line 673.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

> because ( , and ) are illegal
> characters in C function names.
>
>>> I think you are probably using words in a different way than everyone
>>> else so it would be nice to understand your words as well as I
>>> understand Turing machines.
>

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