The Sipser proof is refuted on the basis of showing how Turing machine H
correctly decides reject on ⟨D,⟨D⟩⟩ input on the basis that this input
specifies infinitely nested simulation. Turing machine D correctly
decides accept on ⟨D⟩ input.

The x86utm operating system was created so that the halting problem
could be examined concretely in the high level abstraction of the C
programming language. A simulating partial halt decider written in C
examines the execution trace of its x86 machine language input.

#define u32 uint32_t

int Simulate(u32 P, u32 I)
{ ((void(*)(u32))P)(I);
return 1;
}

int D(u32 P) // P is a machine address
{ if ( H(P, P) )
return 0 // reject when H accepts
return 1; // accept when H rejects
}

int main()
{ u32 HDD_Acceptance = H((u32)D, (u32)D);
u32 DD_Acceptance = D((u32)D);
Output("H(D,D) Would_Halt = ", HDD_Acceptance);
Output("D(D) Would_Halt = ", DD_Acceptance);
}

When we understand that any computation that must have its simulation
aborted to prevent its otherwise infinite execution is correctly
rejected as non-halting then we know that the first line of main() does
correctly reject its input as halting.

A simulating halt decider that never stops simulating its input is
simply a simulator on this input. If H() never stopped simulating D()
then it can be seen that the halting behavior of D() would be the same
as if D() invoked Simulate() instead of H(), thus D() would never
terminate. The above analysis is confirmed by actual execution of the
above function in the x86utm operating system:

(1) The first line of main() detects an infinitely repeating non-halting
pattern on the first line of D. This line must be aborted before ever
returning any value to D. The first line of main() returns 0 for reject.

(2) The second line of main() returns 1 accept on the basis that H
detects an infinitely repeating non-halting pattern and returns 0 for
reject.

Refuting the Sipser Halting Problem Proof
May 2021 PL Olcott
https://www.researchgate.net/publication/351947980_Refuting_the_Sipser_Halting_Problem_Proof

Sipser Section 4.2 The Halting Problem
http://web.cecs.pdx.edu/~black/CS311/Lecture%20Notes/Sipser%20Sect%204.2.pdf

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/2/2021 9:47 PM, Richard Damon wrote:
> On 6/2/21 9:46 PM, olcott wrote:
>> On 6/2/2021 8:14 PM, Richard Damon wrote:
>>> On 6/2/21 8:52 PM, olcott wrote:
>>>
>>>>
>>>> If all inputs can be divided into halting and not halting by one
>>>> definition and cannot be divided into halting and not halting by another
>>>> definition then the second definition is incorrect.
>>>>
>>>
>>> WRONG. First, ALL machine CAN be divided into Halting or Not-Halting by
>>> the classical definition, it is just that WE don't know which side some
>>> machine belong in, but we do know that they definitely fall into one or
>>> the other.
>>>
>>> With your definition, some machine can be 'rightly' decided to fall into
>>> either of the categories, depending on which decide you use. THAT isn't
>>> a very useful definition if your definition of Halting depends on what
>>> machine is doing the testing.
>>
>> On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Truism:
>>>> Every simulation that would never stop unless Halts() stops
>>>> it at some point specifies infinite execution.
>>>
>>> Any algorithm that implements this truism is, of course, a halting
>>> decider.
>>
>> The above truism is equivalent to this truism:
>> Whenever the simulation of the TM description X would not halt on input
>> Y then TM X would not halt on input Y.
>
> Except that you don't process it to that definition.
>
See if you can manage to directly answer this question without getting
distracted:

Would H_Hat ever stop if simulating halt decider H never stopped
simulating it?

#define u32 uint32_t

// Simplified Peter Linz Ĥ
void H_Hat(u32 P)
{ u32 Input_Halts = H(P, P);
if (Input_Halts)
HERE: goto HERE;
}

int main()
{ H((u32)H_Hat, (u32)H_Hat);
}

Everyone else gave up because I would not tolerate their dishonest
dodges of trying to change the subject away from the exact yes or no
question.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/4/2021 9:24 AM, olcott wrote:
> On 6/4/2021 6:44 AM, Richard Damon wrote:
>> On 6/3/21 11:37 PM, olcott wrote:
>>> On 6/3/2021 9:59 PM, Richard Damon wrote:
>>>> On 6/3/21 10:29 PM, olcott wrote:
>>>>> On 6/3/2021 9:09 PM, Richard Damon wrote:
>>>>>> On 6/3/21 9:51 PM, olcott wrote:
>>>>>>> On 6/3/2021 8:39 PM, Richard Damon wrote:
>>>>>>>> On 6/3/21 9:46 AM, olcott wrote:
>>>>>>>>> On 6/3/2021 6:19 AM, Richard Damon wrote:
>>>>>>>>>> On 6/2/21 11:51 PM, olcott wrote:
>>>>>>>>>>> On 6/2/2021 10:11 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-06-02 19:48, olcott wrote:
>>>>>>>>>>>>> On 6/2/2021 8:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/2/21 9:15 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/2/2021 7:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> As I said, it just proves that H can't exist, not that the
>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>> somehow 'wrong'
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Impossible problems occur all the time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Maybe a good example is how to explain to an Olcott what
>>>>>>>>>>>>>>>> Truth
>>>>>>>>>>>>>>>> actually is.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Richard Damon has an IQ == Infinity
>>>>>>>>>>>>>>> && Richard Damon has an IQ != Infinity
>>>>>>>>>>>>>>> ∴ Richard Damon does not exist.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But René Descartes would disagree, as I think, therefore I
>>>>>>>>>>>>>> am.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note, I NEVER have claimed an IQ of infinity, and that by
>>>>>>>>>>>>>> itself
>>>>>>>>>>>>>> would
>>>>>>>>>>>>>> be an impossibility by the definition of IQ. (or, are YOU
>>>>>>>>>>>>>> asserting
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> claim?)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since IQ is based on the normal curve, you can compute
>>>>>>>>>>>>>> what is
>>>>>>>>>>>>>> the
>>>>>>>>>>>>>> highest possible measurable score based on the sample
>>>>>>>>>>>>>> population
>>>>>>>>>>>>>> size.
>>>>>>>>>>>>>> An infinite IQ, would require an infinite population,
>>>>>>>>>>>>>> which is
>>>>>>>>>>>>>> impossible in a finite universe.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Richard Damon likes cats
>>>>>>>>>>>>> && Richard Damon does not like cats
>>>>>>>>>>>>> ∴ Richard Damon does not exist.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is the same reasoning as the diagonal proof so
>>>>>>>>>>>>> I gave it up and went back to Linz.
>>>>>>>>>>>>
>>>>>>>>>>>> All you've demonstrated here is that you are entirely clueless
>>>>>>>>>>>> about
>>>>>>>>>>>> how proofs by contradiction work.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I know how proofs by contradiction work. I have studied the Linz
>>>>>>>>>>> proof
>>>>>>>>>>> since 2004. To refute the Linz proof only requires showing
>>>>>>>>>>> exactly why
>>>>>>>>>>> an Ĥ(⟨Ĥ⟩) transition to its final state of Ĥ.qn is correct.
>>>>>>>>>>
>>>>>>>>>> WHich is exactly saying that you need to prove that a wrong
>>>>>>>>>> answer is
>>>>>>>>>> right.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When halting is defined as any computation that halts without
>>>>>>>>>>> ever
>>>>>>>>>>> having its simulation aborted then the fact that Ĥ(⟨Ĥ⟩) stops
>>>>>>>>>>> running
>>>>>>>>>>> does not indicate that it is a halting computation. The
>>>>>>>>>>> simulating
>>>>>>>>>>> halt
>>>>>>>>>>> decider would also force an infinite loop to stop running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But it isn't defined that way, or at least not the way YOU
>>>>>>>>>> interpret
>>>>>>>>>> that. Your problem is you are SO stuck on simulations that you
>>>>>>>>>> refuese
>>>>>>>>>> to see the fact that the actual running of the machine is what
>>>>>>>>>> matters.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When the actual running of an infinite loop in debug step mode is
>>>>>>>>> aborted it is still an infinite loop and it still stops running.
>>>>>>>>
>>>>>>>> No arguments with that.
>>>>>>>
>>>>>>> If you can agree on this point then this would seem to indicate
>>>>>>> that you
>>>>>>> are capable of understanding what I am saying.
>>>>>>>
>>>>>>>> But also just because your decider does decide
>>>>>>>> to abort the simulation doesn't meen it NEEDED to do so.
>>>>>>>>
>>>>>>>
>>>>>>> If you carefully study the first page of this link
>>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> You will see that it did need to.
>>>>>>
>>>>>> No, it didn't. This can be seen by changing that outer decider to be
>>>>>> just a plain simulator (but keeping the code IN H^ the same). This
>>>>>> simulation will finish and Halt.
>>>>>
>>>>> You keep dodging this question:
>>>>
>>>> I DON'T dodge it, you just ignore the answer.
>>>>
>>>>>
>>>>> Would H_Hat ever stop if simulating halt decider H never stopped
>>>>> simulating it?
>>>>
>>>> Yes, it WILL Stop, at least when you use the proper definitions of the
>>>> wordds.
>>>>
>>>> Replace the top level version of H with your simulator while leaving
>>>> the
>>>> copy in H^ the same AS REQUIRED. (Change H^ and you are answering about
>>>> black cats by looking at white dogs)
>>>>
>>>> WHen we do this, the operation runs to completion and HALTS, therefor
>>>> H^(H^) IS a HALTING computation.
>>>>
>>>>>
>>>>> int Simulate(u32 P, u32 I)
>>>>> {
>>>>>     ((void(*)(u32))P)(I);
>>>>>     return 1;
>>>>> }
>>>>>
>>>>> // Simplified Linz Ĥ (Linz:1990:319)
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>>     u32 Input_Halts = H(P, P);  // Linz H as a partial halt decider
>>>>>     if (Input_Halts)
>>>>>       HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     H((u32)H_Hat, (u32)H_Hat);
>>>>> }
>>>>>
>>>>> If neither H had to stop simulating its input then H_Hat() is a
>>>>> halting
>>>>> computation. If either H had to stop simulating its input then this H
>>>>> decided not halting correctly.
>>>>
>>>>
>>>> Doesn't matter that the H inside did stop its simulation, as that
>>>> doens't abort the simulation we are looking at, and it is part of the
>>>> logic of H^ that we are analyising.
>>>>
>>>
>>> Yes it does matter. If we replace the top level version of H with
>>> Simulate there is still an H that either stops simulating its input or
>>> its input runs forever.
>>>
>>
>> But that H is PART of H^, and thus if makes H^ stop, it is H^ stopping.
>>
>> Would you argue with a pokice office who pulls you over and gives you a
>> ticket because YOU didn't stop at the traffic light, but it was only
>> because the brakes in your car worked that you came to a stop?
>>
>> No, because if something under your control does something, you get
>> credit for it.
>>
>> The ONLY definition of Halting that really matters is what does the
>> machine do when run. Motives and reasons for that behavior don't matter.
>> Actions do.
>>
>> H^ does Halt. Even you admit it. The fact that the copy of H inside it
>> is responsible in a large part doesn't affect this.
>>
>> The classical definition is perfectly fine, it doesn
>>
>>> It is clear that not stopping the simulation (letting its input run
>>> forever) is the wrong choice. The only other choice is stopping the
>>> simulation.
>>
>> So it is Wrong, why is that wrong? You are making the error of presuming
>> that it exists.
>>
>>>
>>> If there are only two possible choices of (A) and (B) and we can know
>>> with perfect certainty that (A) is the wrong choice then we really need
>>> to perfectly grok (B) before dismissing it out-of-hand.
>>
>> And if B is also wrong then we know the question has no correct answer.
>> Not all questions do.
>>>
>>> Both Ben and Kaz do seem to understand the truism:
>>>
>>> On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> Truism:
>>>>> Every simulation that would never stop unless Halts() stops
>>>>> it at some point specifies infinite execution.
>>>>
>>>> Any algorithm that implements this truism is, of course, a halting
>>>> decider.
>>>
>>
>> It might be an Olcoot-Halting Decider, but your H is an incorrect
>> Computation Theory Halting Decider, because you are using a wrong
>> definition.
>>
>> You are baseing it on a Falsehood.
>>
>> The RIGHT Truism would be Every simulation that would never stop unless
>> the Decider Simulating it corrctly stops it specifies an infinite
>> execution.
>>
>> The problem with this Truism is that it is useless for showing
>> non-halting as only CORRECTLY stopping matters, so you need a REAL proof
>> that it is non-halting before you can use this to be able to say it is.
>>
>
> This proof may be over your head.
>
> int Simulate(u32 P, u32 I)
> {
>   ((void(*)(u32))P)(I);
>   return 1;
> }
>
> // Simplified Linz Ĥ (Linz:1990:319)
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = H(P, P);  // Linz H as a partial halt decider
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> // Simplified Linz Ĥ (Linz:1990:319)
> void H_Hat2(u32 P)
> {
>   u32 Input_Halts = Simulate(P, P);  // Linz H as a partial halt decider
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> int main()
> {
>   Simulate((u32)H_Hat2,(u32)H_Hat2);
>   Simulate((u32)H_Hat, (u32)H_Hat);
> }
>
> Anyone that knows programming will know that line 1 of main won't halt.
> Also anyone that knows programming will know that line 1 of main will
> only halt if H stops simulating H_Hat().
>
> You just might not be bright enough to see that this proves that H must
> stop simulating _H_Hat on line two.
>
>> Remember, a given H^ is built on a particular implementation of H, and
>> thus the question of what should H do isn't a valid question at this
>> point, as it has already been established when H was given. H MUST do
>> what H was programmed to do. Turing Machines are machines of
>> deterministic calculation, you logic is presuming a volatile mode of
>> calculation, where H might change what it does based on something
>> outside its determined programming.
>>
>> Maybe if you could ACTUALLY create a machine that could actually DO this
>> sort method of computation, you could revolutionize the field. Note,
>> this doesn't mean that some outside agent changes the machine, as that
>> says that the outside agent is now 'part' of the decider, you need the
>> machine to do this itself, consistently but not mechanically so that you
>> can break out of the Turing Trap.

On 6/7/2021 9:45 PM, Richard Damon wrote:
> On 6/7/21 10:26 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> You are free to create a DIFFERENT system, and in that define your
>>> Olcott-Halting however you want, but it is a DIFFERENT system and does
>>> not apply to the original or any of that original's uses.
>>
>> And it too is undecidable in the general case! Whilst this silly
>> notation was concocted as an excuse for returning the wrong result for
>> the one instance PO obsesses about, he's claimed to have a design that
>> detects those, and only those, computations that have to be stopped.
>> But that's impossible. An infinity to halting computations have to be
>> stopped early or he'd have a conventional halting decider.
>>
>
> Yes, he reaches his stated goal of making that class of proofs not work
> in his system, but halting is still not deciable, unless it is
> considered decidable because the system is inconsistent which mean ALL
> machines can be 'proven' to be Halting and Non-Halting at the same time
> (due to the principle of the propagation of inconsistency).
>

Every computation that would never halt unless its simulation is aborted
is a computation that specifies infinite execution even after it has
been forced to halt.

void Infinite_Loop()
{ HERE: goto HERE;
}

int main()
{ u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
Output("Input_Would_Halt2 = ", Input_Would_Halt2);
}

_Infinite_Loop()
[00000a90](01) 55 push ebp
[00000a91](02) 8bec mov ebp,esp
[00000a93](02) ebfe jmp 00000a93
[00000a95](01) 5d pop ebp
[00000a96](01) c3 ret
Size in bytes:(0007) [00000a96]

_main()
[00000b40](01) 55 push ebp
[00000b41](02) 8bec mov ebp,esp
[00000b43](01) 51 push ecx
[00000b44](05) 68900a0000 push 00000a90
[00000b49](05) 68900a0000 push 00000a90
[00000b4e](05) e8edfdffff call 00000940
[00000b53](03) 83c408 add esp,+08
[00000b56](03) 8945fc mov [ebp-04],eax
[00000b59](03) 8b45fc mov eax,[ebp-04]
[00000b5c](01) 50 push eax
[00000b5d](05) 682b030000 push 0000032b
[00000b62](05) e8f9f7ffff call 00000360
[00000b67](03) 83c408 add esp,+08
[00000b6a](02) 33c0 xor eax,eax
[00000b6c](02) 8be5 mov esp,ebp
[00000b6e](01) 5d pop ebp
[00000b6f](01) c3 ret
Size in bytes:(0048) [00000b6f]

===============================
....[00000b40][00101533][00000000](01) 55 push ebp
....[00000b41][00101533][00000000](02) 8bec mov ebp,esp
....[00000b43][0010152f][00000000](01) 51 push ecx
....[00000b44][0010152b][00000a90](05) 68900a0000 push 00000a90
....[00000b49][00101527][00000a90](05) 68900a0000 push 00000a90
....[00000b4e][00101523][00000b53](05) e8edfdffff call 00000940
Begin Local Halt Decider Simulation at Machine Address:a90
....[00000a90][002115d3][002115d7](01) 55 push ebp
....[00000a91][002115d3][002115d7](02) 8bec mov ebp,esp
....[00000a93][002115d3][002115d7](02) ebfe jmp 00000a93
....[00000a93][002115d3][002115d7](02) ebfe jmp 00000a93
Local Halt Decider: Infinite Loop Detected Simulation Stopped
....[00000b53][0010152f][00000000](03) 83c408 add esp,+08
....[00000b56][0010152f][00000000](03) 8945fc mov [ebp-04],eax
....[00000b59][0010152f][00000000](03) 8b45fc mov eax,[ebp-04]
....[00000b5c][0010152b][00000000](01) 50 push eax
....[00000b5d][00101527][0000032b](05) 682b030000 push 0000032b
---[00000b62][00101527][0000032b](05) e8f9f7ffff call 00000360
Input_Would_Halt2 = 0
....[00000b67][0010152f][00000000](03) 83c408 add esp,+08
....[00000b6a][0010152f][00000000](02) 33c0 xor eax,eax
....[00000b6c][00101533][00000000](02) 8be5 mov esp,ebp
....[00000b6e][00101537][00100000](01) 5d pop ebp
....[00000b6f][0010153b][00000050](01) c3 ret
Number_of_User_Instructions(21)
Number of Instructions Executed(640)

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/7/2021 10:36 PM, Richard Damon wrote:
> On 6/7/21 11:27 PM, olcott wrote:
>> On 6/7/2021 10:08 PM, Richard Damon wrote:
>>> On 6/7/21 10:48 PM, olcott wrote:
>>>> All that I have shown is that the conventional halting problem proofs do
>>>> not prove that all inputs cannot be divided into those that halt and
>>>> those that would not halt unless their simulation was aborted.
>>>
>>> Except that H_Hat belongs to Both, as it DOES Halt, and if you use a
>>> different halt decider than this H, but some alternate version, THAT one
>>> will correctly decide it to be Halting.
>>>
>>> Thus you division is inconsistent.
>>
>> No invocation of H_Hat() ever halts unless some H_Hat() has had its
>> simulation aborted.
>>
>> Here is the appropriate analogy:
>> Infinite recursion that is cut off because one of its otherwise
>> infinitely recursive calls was stopped must still be construed as
>> infinite recursion for the entire chain of calls.
>>
>>
>
> BUT, SINCE H Does abort its simulation, H_Hat does Halt, so H was wrong.

When H aborts the simulation of an infinite loop H is correct.

When H aborts the simulation of infinite recursion no matter which
recursive call it aborts it correctly decides that the whole call chain
was infinitely recursive.

It is the same thing with H_Hat(H_Hat).

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/8/2021 8:17 PM, Richard Damon wrote:
> On 6/8/21 9:25 AM, olcott wrote:
>> On 6/8/2021 6:25 AM, Richard Damon wrote:
>>> On 6/7/21 11:41 PM, olcott wrote:
>>>> On 6/7/2021 10:36 PM, Richard Damon wrote:
>>>>> On 6/7/21 11:27 PM, olcott wrote:
>>>>>> On 6/7/2021 10:08 PM, Richard Damon wrote:
>>>>>>> On 6/7/21 10:48 PM, olcott wrote:
>>>>>>>> All that I have shown is that the conventional halting problem
>>>>>>>> proofs do
>>>>>>>> not prove that all inputs cannot be divided into those that halt and
>>>>>>>> those that would not halt unless their simulation was aborted.
>>>>>>>
>>>>>>> Except that H_Hat belongs to Both, as it DOES Halt, and if you use a
>>>>>>> different halt decider than this H, but some alternate version, THAT
>>>>>>> one
>>>>>>> will correctly decide it to be Halting.
>>>>>>>
>>>>>>> Thus you division is inconsistent.
>>>>>>
>>>>>> No invocation of H_Hat() ever halts unless some H_Hat() has had its
>>>>>> simulation aborted.
>>>>>>
>>>>>> Here is the appropriate analogy:
>>>>>> Infinite recursion that is cut off because one of its otherwise
>>>>>> infinitely recursive calls was stopped must still be construed as
>>>>>> infinite recursion for the entire chain of calls.
>>>>>>
>>>>>>
>>>>>
>>>>> BUT, SINCE H Does abort its simulation, H_Hat does Halt, so H was
>>>>> wrong.
>>>>
>>>> When H aborts the simulation of an infinite loop H is correct.
>>>
>>> But answering that H_Hat is non-Halting is incorrect, because
>>> H_Hat(H_Hat) does halt, right? You have previously admitted thatm
>>>
>>>>
>>>> When H aborts the simulation of infinite recursion no matter which
>>>> recursive call it aborts it correctly decides that the whole call chain
>>>> was infinitely recursive.
>>>
>>> But, since H DOES abort it, it isn't infinite recursion. THAT is the
>>> point you miss.
>>>
>>
>> That is not the way that it works.
>
> Why Not? Do you have any authoratitive grounds to say otherwise?
>
> Maybe you problem is you just don't understand what words actually mean.
>
> Halting means it does come to a stop, Non-Halting means it never comes
> to a stop.
>

This is self-evident (true on the basis of the meaning of its words).
Every computation that only stops because its simulation was aborted is
not a halting computation even when its simulating halt decider forces
it to stop.

> Even you have agreed that H_Hat(H_Hat) will come to a Halt, thus it IS a
> Halting Computation.
>

It halts in exactly the same way that an infinitely recursive sequence
of function calls comes to a halt if any one of them is forced to halt.

The fact that a simulating halt decider forced one of these otherwise
infinitely recursive function calls to halt does not mean that this was
not an infinitely recursive sequence of function calls.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/10/2021 2:10 PM, dklei...@gmail.com wrote:
> On Thursday, June 10, 2021 at 4:42:31 AM UTC-7, olcott wrote:
>
>> I guess that we are done here.
>
> That was a mighty mess. I am delighted it is finally done.
>
> Would you please tell us just what you proved?
>

The standard pseudo-code halting problem template "proved" that the
halting problem could never be solved on the basis that neither value of
true (halting) nor false (not halting) could be correctly returned to
the confounding input.

Halting Problem -- Simple Proof
https://www.comp.nus.edu.sg/~cs5234/FAQ/halt.html

The problem is overcome on the basis that the halt decider aborts its
simulation of this input before ever returning any value to this input.

The halt decider aborts the simulation of its input on the basis that
its input specifies what is essentially infinite recursion to any
simulating halt decider.

I have also shown that this same reasoning is directly applied to the
Peter Linz halting problem proof.

void H_Hat(u32 P)
{ u32 Input_Halts = H(P, P);
if (Input_Halts)
HERE: goto HERE;
}

int main()
{ u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt6 = ", Input_Would_Halt6);
}

http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/10/2021 2:58 PM, olcott wrote:
> On 6/10/2021 2:10 PM, dklei...@gmail.com wrote:
>> On Thursday, June 10, 2021 at 4:42:31 AM UTC-7, olcott wrote:
>>
>>> I guess that we are done here.
>>
>> That was a mighty mess. I am delighted it is finally done.
>>
>> Would you please tell us just what you proved?
>>
>
> The standard pseudo-code halting problem template "proved" that the
> halting problem could never be solved on the basis that neither value of
> true (halting) nor false (not halting) could be correctly returned to
> the confounding input.
>
> Halting Problem -- Simple Proof
> https://www.comp.nus.edu.sg/~cs5234/FAQ/halt.html
>
> The problem is overcome on the basis that the halt decider aborts its
> simulation of this input before ever returning any value to this input.
>
> The halt decider aborts the simulation of its input on the basis that
> its input specifies what is essentially infinite recursion to any
> simulating halt decider.
>
> I have also shown that this same reasoning is directly applied to the
> Peter Linz halting problem proof.
>
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = H(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> int main()
> {
>   u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>   Output("Input_Would_Halt6 = ", Input_Would_Halt6);
> }
>

Here is the right link:
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein