On 3/15/24 9:23 PM, olcott wrote:
> 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.
>
> A termination analyzer must have some way to predicate this.
> H(D,D) can only predict what it actually sees and H(D,D)
> sees that it must abort the simulation of its input.
>

On 3/15/24 8:41 PM, olcott wrote:
> 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.
>
>> So, you lie.
>>
>>>
>>>> Perhaps you can claim your "Need to abort" criteria is meet, but
>>>> that still isn't the halting criteria.
>>>
>>> When we mutually agree that H(D,D) does correctly determine
>>> that it must abort its simulation of D(D) and show how and
>>> why this is correct then we can move on to the next point.
>>>
>>
>> But we have proved that the aborting criteria is not a Halting Criteria.
>>
> The abort criteria derives the exact same result as the
> conventional halting criteria yet does not make the mistake
> of expecting H to report on behavior that it does not see.
> In these cases it derives a different result.
>

On 3/15/2024 11:52 PM, Richard Damon wrote:
> On 3/15/24 8:41 PM, olcott wrote:
>> 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.
>>
>>> So, you lie.
>>>
>>>>
>>>>> Perhaps you can claim your "Need to abort" criteria is meet, but
>>>>> that still isn't the halting criteria.
>>>>
>>>> When we mutually agree that H(D,D) does correctly determine
>>>> that it must abort its simulation of D(D) and show how and
>>>> why this is correct then we can move on to the next point.
>>>>
>>>
>>> But we have proved that the aborting criteria is not a Halting Criteria.
>>>
>> The abort criteria derives the exact same result as the
>> conventional halting criteria yet does not make the mistake
>> of expecting H to report on behavior that it does not see.
>> In these cases it derives a different result.
>>
>
> So, you are saying Halting == Not Halting, since the conventional
> Halting Criteria says that D(D) Halts, since H(D,D) says 0, and D is
> designed to halt if H(D,D) says 0.
>
> And your abort criteria says it is non-halting.
>
> So, BOOM, you logic system just exploded in contradiciton, or you admit
> you are a liar.

On 3/15/24 10:00 PM, olcott wrote:
> On 3/15/2024 11:52 PM, Richard Damon wrote:
>> On 3/15/24 8:41 PM, olcott wrote:
>>> 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.
>>>
>>>> So, you lie.
>>>>
>>>>>
>>>>>> Perhaps you can claim your "Need to abort" criteria is meet, but
>>>>>> that still isn't the halting criteria.
>>>>>
>>>>> When we mutually agree that H(D,D) does correctly determine
>>>>> that it must abort its simulation of D(D) and show how and
>>>>> why this is correct then we can move on to the next point.
>>>>>
>>>>
>>>> But we have proved that the aborting criteria is not a Halting
>>>> Criteria.
>>>>
>>> The abort criteria derives the exact same result as the
>>> conventional halting criteria yet does not make the mistake
>>> of expecting H to report on behavior that it does not see.
>>> In these cases it derives a different result.
>>>
>>
>> So, you are saying Halting == Not Halting, since the conventional
>> Halting Criteria says that D(D) Halts, since H(D,D) says 0, and D is
>> designed to halt if H(D,D) says 0.
>>
>> And your abort criteria says it is non-halting.
>>
>> So, BOOM, you logic system just exploded in contradiciton, or you
>> admit you are a liar.
>
> I admit that the original criteria is incorrect when the basis
> is that H(D,D) always reports on the behavior that it actually sees.
>
> On the different basis of dividing program/input pairs into those
> that halt and those that do not, we need a third return value of ERROR.

On 2024-03-15 16:20:35 +0000, olcott said:

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

This proof is not simpler or more convinceing than earlier proofs of
the same.

It is also as uninteresting as the proved claim. As long as H does
not meet the specification of halting decider it does not matter
what it meets instead.

--
Mikko

On 2024-03-15 20:25:50 +0000, olcott said:

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

On 2024-03-15 18:45:34 +0000, immibis said:

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

But it makes the author look stupid, which may be the
right thing to do.

--
Mikko

On 2024-03-15 18:38:23 +0000, immibis said:

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

Counting to two is not as trivial as some people think.

--
Mikko

On 2024-03-15 19:40:08 +0000, olcott said:

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

Then you cannot prove that H is a halting decider, as that is what
you need to reference in the proof.

Fortunately, for topic of this discussion there is no need to prove that
H is a halting decider.

--
Mikko

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

I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
that H correctly determined that it had to abort the simulation
of its input to prevent the infinite execution of this input.

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.

--
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/16/2024 3:51 AM, Mikko wrote:
> On 2024-03-15 18:38:23 +0000, immibis said:
>
>> 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?
>
> Counting to two is not as trivial as some people think.
>

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.

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

I keep posting the same point until it gets a complete and correct
review. This has proved to be very effective in that I am finally
getting complete closure on some of these points.

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.

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

Op 16.mrt.2024 om 15:49 schreef olcott:
> On 3/16/2024 3:51 AM, Mikko wrote:
>> On 2024-03-15 18:38:23 +0000, immibis said:
>>
>>> 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?
>>
>> Counting to two is not as trivial as some people think.
>>
>
> 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.
>
>

Indeed. Exactly. That proves that there cannot possibly exist a halting
decider. Because that H that aborts returns the wrong answer and
therefore is not a halting decider either.

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

On 3/16/2024 3:19 AM, Mikko wrote:
> On 2024-03-15 16:20:35 +0000, olcott said:
>
>> 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).
>
> This proof is not simpler or more convinceing than earlier proofs of
> the same.
>
> It is also as uninteresting as the proved claim. As long as H does
> not meet the specification of halting decider it does not matter
> what it meets instead.
>

The original halt status criteria has the impossible requirement
that H(D,D) must report on behavior that it does not actually see.
Requiring H to be clairvoyant is an unreasonable requirement.
*The criteria shown below eliminate the requirement of clairvoyance*

(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

*H correctly simulates its input D until*
Means H does a correct partial simulation of D until H correctly
matches the recursive simulation non-halting behavior pattern.

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.

--
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/16/2024 10:00 AM, Fred. Zwarts wrote:
> Op 16.mrt.2024 om 15:49 schreef olcott:
>> On 3/16/2024 3:51 AM, Mikko wrote:
>>> On 2024-03-15 18:38:23 +0000, immibis said:
>>>
>>>> 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?
>>>
>>> Counting to two is not as trivial as some people think.
>>>
>>
>> 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.
>>
>>
>
> Indeed. Exactly. That proves that there cannot possibly exist a halting
> decider. Because that H that aborts returns the wrong answer and
> therefore is not a halting decider either.

The original halt status criteria has the impossible requirement
that H(D,D) must report on behavior that it does not actually see.
Requiring H to be clairvoyant is an unreasonable requirement.
*The criteria shown below eliminate the requirement of clairvoyance*

(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

*H correctly simulates its input D until*
Means H does a correct partial simulation of D until H correctly
matches the recursive simulation non-halting behavior pattern.

--
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/16/2024 12:22 AM, Richard Damon wrote:
> On 3/15/24 10:00 PM, olcott wrote:
>> On 3/15/2024 11:52 PM, Richard Damon wrote:
>>> On 3/15/24 8:41 PM, olcott wrote:
>>>> 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.
>>>>
>>>>> So, you lie.
>>>>>
>>>>>>
>>>>>>> Perhaps you can claim your "Need to abort" criteria is meet, but
>>>>>>> that still isn't the halting criteria.
>>>>>>
>>>>>> When we mutually agree that H(D,D) does correctly determine
>>>>>> that it must abort its simulation of D(D) and show how and
>>>>>> why this is correct then we can move on to the next point.
>>>>>>
>>>>>
>>>>> But we have proved that the aborting criteria is not a Halting
>>>>> Criteria.
>>>>>
>>>> The abort criteria derives the exact same result as the
>>>> conventional halting criteria yet does not make the mistake
>>>> of expecting H to report on behavior that it does not see.
>>>> In these cases it derives a different result.
>>>>
>>>
>>> So, you are saying Halting == Not Halting, since the conventional
>>> Halting Criteria says that D(D) Halts, since H(D,D) says 0, and D is
>>> designed to halt if H(D,D) says 0.
>>>
>>> And your abort criteria says it is non-halting.
>>>
>>> So, BOOM, you logic system just exploded in contradiciton, or you
>>> admit you are a liar.
>>
>> I admit that the original criteria is incorrect when the basis
>> is that H(D,D) always reports on the behavior that it actually sees.
>>
>> On the different basis of dividing program/input pairs into those
>> that halt and those that do not, we need a third return value of ERROR.
>
> But, Halting isn't a function of the decider, so the "program" part of
> the Program/Input pair we want are the Program encoded in the
> description with the input it is given.
>

On 3/15/2024 11:43 PM, Richard Damon wrote:
> On 3/15/24 9:23 PM, olcott wrote:
>> 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.
>>
>> A termination analyzer must have some way to predicate this.
>> H(D,D) can only predict what it actually sees and H(D,D)
>> sees that it must abort the simulation of its input.
>>
>
> WHY must it?
>
We could say that a termination analyzer only needs to be able
to play tic-tac-toe badly.

On 3/15/2024 11:29 PM, Richard Damon wrote:
> 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.
>
> So?
>
> The fact that H must abort to give an answer doesn't mean it get to
> abort and guess the wrong answer.
>
> Again, you are admitting that you think it is ok to lie to make people
> think you know what you are doing.
>
>>
>>> You think you can prove an INCORRECT program as correct.
>>>
>>> (Since D(D) Halts, H(D,D) returning 0 is just WRONG for a Halt Decider).
>>>
>>
>> H(D,D) fails to make the required mistake of reporting on what it does
>> not see.
>
> But it DOES make a mistake, because it does answer the question correctly.
>
> You are just PROVING you think lying is ok.
>
> You TOTALLY don't understand the meaning of truth.
>
> You are REALLY just a Pathological Liar, as you have no concept of real
> truth,
>

Op 16.mrt.2024 om 16:20 schreef olcott:
> On 3/16/2024 10:00 AM, Fred. Zwarts wrote:
>> Op 16.mrt.2024 om 15:49 schreef olcott:
>>> On 3/16/2024 3:51 AM, Mikko wrote:
>>>> On 2024-03-15 18:38:23 +0000, immibis said:
>>>>
>>>>> 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?
>>>>
>>>> Counting to two is not as trivial as some people think.
>>>>
>>>
>>> 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.
>>>
>>>
>>
>> Indeed. Exactly. That proves that there cannot possibly exist a
>> halting decider. Because that H that aborts returns the wrong answer
>> and therefore is not a halting decider either.
>
> The original halt status criteria has the impossible requirement
> that H(D,D) must report on behavior that it does not actually see.
> Requiring H to be clairvoyant is an unreasonable requirement.
> *The criteria shown below eliminate the requirement of clairvoyance*
>
> (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
>
> *H correctly simulates its input D until*
> Means H does a correct partial simulation of D until H correctly
> matches the recursive simulation non-halting behavior pattern.
>

Olcott is almost there. He only needs to see that H does not need to be
clairvoyant, but it needs computability of the halting requirement. The
halting problem is not computable. Therefore, no halting decider exists.

On 3/16/2024 10:31 AM, Fred. Zwarts wrote:
> Op 16.mrt.2024 om 16:20 schreef olcott:
>> On 3/16/2024 10:00 AM, Fred. Zwarts wrote:
>>> Op 16.mrt.2024 om 15:49 schreef olcott:
>>>> On 3/16/2024 3:51 AM, Mikko wrote:
>>>>> On 2024-03-15 18:38:23 +0000, immibis said:
>>>>>
>>>>>> 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?
>>>>>
>>>>> Counting to two is not as trivial as some people think.
>>>>>
>>>>
>>>> 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.
>>>>
>>>>
>>>
>>> Indeed. Exactly. That proves that there cannot possibly exist a
>>> halting decider. Because that H that aborts returns the wrong answer
>>> and therefore is not a halting decider either.
>>
>> The original halt status criteria has the impossible requirement
>> that H(D,D) must report on behavior that it does not actually see.
>> Requiring H to be clairvoyant is an unreasonable requirement.
>> *The criteria shown below eliminate the requirement of clairvoyance*
>>
>> (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
>>
>> *H correctly simulates its input D until*
>> Means H does a correct partial simulation of D until H correctly
>> matches the recursive simulation non-halting behavior pattern.
>>
>
> Olcott is almost there. He only needs to see that H does not need to be
> clairvoyant, but it needs computability of the halting requirement. The
> halting problem is not computable. Therefore, no halting decider exists.
>

The original requirement is isomorphic to correctly answering
this incorrect question:
Is this sentence true or false: "This sentence is not true" ?

PhD fully professors of computer science agree with me on this.
Professor Hehner specifically agrees (in a private email):
"that the halting problem cannot be solved
because there is something wrong with it."

E C R Hehner. Objective and Subjective Specifications
WST Workshop on Termination, Oxford. 2018 July 18.
See https://www.cs.toronto.edu/~hehner/OSS.pdf

Bill Stoddart. The Halting Paradox
20 December 2017
https://arxiv.org/abs/1906.05340
arXiv:1906.05340 [cs.LO]

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

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

Right, because Halting Deciders have been proven impossible.

You keep on proving that, and then claim that you have a way to refute
that, but you seem to think asserting it will refute it.

That isn't the way logic works.

And H(D,D) not giving the right answer doesn't mean that there isn't a
right answer.

After all, Truth is Truth, even if no one knows it.

Something that seem strange to you because you confuse Truth and Knowledge.

On 3/16/2024 10:45 AM, Richard Damon wrote:
> On 3/16/24 8:09 AM, olcott wrote:
>> On 3/16/2024 3:29 AM, Mikko wrote:
>>> On 2024-03-15 20:25:50 +0000, olcott said:
>>>
>>>> On 3/15/2024 3:06 PM, Richard Damon wrote:
>>>>> On 3/15/24 12:53 PM, olcott wrote:
>>>>>> On 3/15/2024 2:49 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 12:25 PM, olcott wrote:
>>>>>>>> On 3/15/2024 2:19 PM, Richard Damon wrote:
>>>>>>>>> On 3/15/24 12:06 PM, olcott wrote:
>>>>>>>>>> On 3/15/2024 1:31 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/15/24 10:23 AM, olcott wrote:
>>>>>>>>>>>>> On 3/15/2024 12:07 PM, immibis wrote:
>>>>>>>>>>>>>> On 15/03/24 17:20, olcott wrote:
>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim
>>>>>>>>>>>>>>> paragraph is correct*
>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in
>>>>>>>>>>>>>>> this paper)
>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its
>>>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>>>> would never stop running unless aborted then
>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report
>>>>>>>>>>>>>>> that D specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ;
>>>>>>>>>>>>>>> begin main()
>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>>>>> push DD
>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>>>>> push D
>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ;
>>>>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp
>>>>>>>>>>>>>>> ; enter D(D)
>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax
>>>>>>>>>>>>>>> ; push D
>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx
>>>>>>>>>>>>>>> ; push D
>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522
>>>>>>>>>>>>>>> ; call H(D,D)
>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called
>>>>>>>>>>>>>>> with its same inputs and there are no conditional branch
>>>>>>>>>>>>>>> instructions between the invocation of D(D) and its call
>>>>>>>>>>>>>>> to H(D,D).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There are conditional branch instructions inside H(D,D).
>>>>>>>>>>>>>> This is obvious. Why do you keep lying?
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its
>>>>>>>>>>>>> input D until
>>>>>>>>>>>>> H correctly determines that its simulated D would never
>>>>>>>>>>>>> stop running
>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is true that D(D) would never stop running unless the
>>>>>>>>>>>>> outermost H(D,D) aborts its simulation thus meeting the
>>>>>>>>>>>>> above criteria.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, not if D is claimed to be the equivalent of Linz H^.
>>>>>>>>>>>>
>>>>>>>>>>>> If you are willing to DISAVOW any posssible conntection to
>>>>>>>>>>>> that we can discuss that version, but then you are admitting
>>>>>>>>>>>> this is just a time wasting change of topic.
>>>>>>>>>>>>
>>>>>>>>>>>> The issue becomes a definition of identity.
>>>>>>>>>>>>
>>>>>>>>>>>> IF we are in an equivalency to Linz H/H^, then the H that D
>>>>>>>>>>>> calls is a seperate identity to the H that is simulating
>>>>>>>>>>>> that D.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, the outer H doesn't NEED to abort,
>>>>>>>>>>>
>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>>>>>>> until H correctly determines that its simulated D would never
>>>>>>>>>>> stop
>>>>>>>>>>> running unless aborted then
>>>>>>>>>>>
>>>>>>>>>>> That is incorrect yet too difficult for you to understand
>>>>>>>>>>> that it is incorrect until after you first understand that
>>>>>>>>>>> D(D,D)==0 is correct for the above criteria.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Typo I meant H(D,D).
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WHich I assumed as a possibility and refuted.
>>>>>>>>>
>>>>>>>>> H(D,D) == 0 can't be the correct answer for a Halting Decider
>>>>>>>>> as D(D) Halts, so the correct answer would be 1.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *That is the strawman deception to the title of this thread*
>>>>>>>
>>>>>>> But your title is refering to your own strawman.
>>>>>>
>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>>> correct*
>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>> until H correctly determines that its simulated D would never stop
>>>>>> running unless aborted then
>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>>
>>>>>> Not at all. This thread is all about whether or not H(D,D) meets
>>>>>> its abort criteria.
>>>>>>
>>>>>
>>>>> Which, because you ask Profeser Sipser, about Turing Machine
>>>>> equivalents,
>>>>
>>>> It was always about x86 emulators simulating C functions.
>>>
>>> No, what Professor Sipser agreed with does not mention C, functions,
>>> nor x86. He clearly said he agrees with only that and no more.
>>>
>>
>> *This is the same version 10/10/22 11:36:14 AM*
>> *that professor Sipser was presented with*
>>
>> Rebutting the Sipser Halting Problem Proof
>> https://philarchive.org/archive/OLCRTSv1
>>
>
> Rigth, so not at all with what you claim he was talking about.
>
> As fully explained elsewhere and you ignored.
>
> You are thus just proven to be a stupid liar.

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

Except that it THIS H actually DID need to abort its simulation, then
when we run the input, it should not halt.

The arguments about other H's is jut invalid,

In fact, your criteria, the way you interpret it is invalid, as it
requires looking at, as *H*, a machine that just is't H. That means your
logic is based on a plainly false premise.