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.

This problem is overcome on the basis that the halt decider aborts its
simulation of this input before ever returning any value. It aborts the
simulation of its input on the basis that its input specifies what is
essentially infinite recursion to any simulating halt decider.

procedure compute_g(i):
if f(i, i) == 0 then
return 0
else
loop forever // (Wikipedia:Halting Problem)

https://en.wikipedia.org/wiki/Halting_problem

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

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

Halting problem undecidability and infinitely nested simulation

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

On 6/10/21 10:56 PM, olcott wrote:
> 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.

SO you accept that Linz is RIGHT. That there IS no halt decider that can
always give a correct answer to the REAL halting problem definiton.

>
> This problem is overcome on the basis that the halt decider aborts its
> simulation of this input before ever returning any value. It aborts the
> simulation of its input on the basis that its input specifies what is
> essentially infinite recursion to any simulating halt decider.

But, aborting the simulation doesn't actually show anything about the
actual problem. Since the Simulating Halt Decider returns its answer to
its caller (or it fails to be a halt decider) it still is in the
cundundrum that whatever answer it gives will still be wrong.

You logic fails on that fact that the Halt Decider, by definition, must
always give the same answer to a given problem, and thus if it DOES
abort a given input, it will and has ALWAYS aborted that input and thus
it it NOT infinitely recursive on that input.

This is like the person looking for his lost keys under a street lamp,
and when the passer by asks how it lost them, and he points to the
nearby field and says he dropped them while crossing the field. When
asked why he is looking here instead of there, he says because the light
is here.

You are looking for an answer in the place without one. You can not find
an answer to the Halting Problem if you leave the definitions of the
Halting Problem behind. It just doesn't work.

Yes, you can claim that you can define Olcott-Halting in a way that one
proof against Halting doesn't apply to Olcott-Halting, but that doesn't
even mean that it is possible to always decide Olcott-Halting. It also
doesn't mean Olcott-Halting is useful for anything.

It definitely doesn't mean you have refuted the proofs that there is no
such thing as an actual universally correct Halt Decider, so it doesn't
prove anything like what you want to claim.

You can't prove a statement about black cats by using a white dog.

>
> procedure compute_g(i):
>   if f(i, i) == 0 then
>     return 0
>   else
>     loop forever    // (Wikipedia:Halting Problem)
>
> https://en.wikipedia.org/wiki/Halting_problem
>
> // Simplified Linz Ĥ (Linz:1990:319)
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = H(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> int main()
> {
>   H_Hat((u32)H_Hat, (u32)H_Hat);
> }
>
> Halting problem undecidability and infinitely nested simulation
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>

On 6/11/2021 5:27 AM, Richard Damon wrote:
> On 6/10/21 10:56 PM, olcott wrote:
>> 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.
>
> SO you accept that Linz is RIGHT. That there IS no halt decider that can
> always give a correct answer to the REAL halting problem definiton.
>
>>
>> This problem is overcome on the basis that the halt decider aborts its
>> simulation of this input before ever returning any value. It aborts the
>> simulation of its input on the basis that its input specifies what is
>> essentially infinite recursion to any simulating halt decider.
>
>
> But, aborting the simulation doesn't actually show anything about the
> actual problem. Since the Simulating Halt Decider returns its answer to
> its caller (or it fails to be a halt decider) it still is in the
> cundundrum that whatever answer it gives will still be wrong.
>

void Infinite_Loop()
{ HERE: goto HERE;
}

int Infinite_Recursion(u32 N)
{ u32 M = Infinite_Recursion(N);
return M;
}

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

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

u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
Output("Input_Would_Halt3 = ", Input_Would_Halt3);

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

In all three of the above cases H must abort the simulation
of its input and report that its input does not halt.

This is apparently beyond your intellectual capacity or ability to pay
attention.

>>
>> Halting problem undecidability and infinitely nested simulation
>>
>> 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

On 6/11/21 10:03 AM, olcott wrote:
> On 6/11/2021 5:27 AM, Richard Damon wrote:
>> On 6/10/21 10:56 PM, olcott wrote:
>>> 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.
>>
>> SO you accept that Linz is RIGHT. That there IS no halt decider that can
>> always give a correct answer to the REAL halting problem definiton.
>>
>>>
>>> This problem is overcome on the basis that the halt decider aborts its
>>> simulation of this input before ever returning any value. It aborts the
>>> simulation of its input on the basis that its input specifies what is
>>> essentially infinite recursion to any simulating halt decider.
>>
>>
>> But, aborting the simulation doesn't actually show anything about the
>> actual problem. Since the Simulating Halt Decider returns its answer to
>> its caller (or it fails to be a halt decider) it still is in the
>> cundundrum that whatever answer it gives will still be wrong.
>>
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> int Infinite_Recursion(u32 N)
> {
>   u32 M = Infinite_Recursion(N);
>   return M;
> }
>
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = H(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> int main()
> {
>   u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>   Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>
>   u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>   Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>
>   u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>   Output("Input_Would_Halt6 = ", Input_Would_Halt6);
> }
>
> In all three of the above cases H must abort the simulation
> of its input and report that its input does not halt.

WRONG QUESTION.

In th 3rd case, yes, for H to be able to return an answer, it must abort
the simulation, but the answer of non-halting is wrong.

This is shown by running H_Ht with that same H, and we see that it will
run and halt.

Thus the answer of non-halting is wrong. PERIOD.

You have given ZERO PROOF that the answer should be considered right.

Part of the problem is that since H_Hat uses H, you need to use better
logic to include the fact that H might stop its simulation.

Yes, if H doesn't abort its simulation, then H_Hat will be non-halting,
but then that H won't be able to return an answer so it will also fail
to be a halt decider.

The right answer to the halting behavior MUST look at the right version
of that computation, so since an H that can answer will abort the
simulation, it needs to take that operation into account when it
determines what answer to give.

It turns out that an H that gives the right answer is impossible to
actually create, so you get strange logic when you begin by assuming
that it exists. Unicorns defy the laws of logic.

> This is apparently beyond your intellectual capacity or ability to pay
> attention.

No, just beyond yours. Your think is at least one step behind reality,
you don't think far enough to see that H does abort its simulation and
this actually allows the H_Hat that is using that H to return its answer
and be halting.

>
>>>
>>> Halting problem undecidability and infinitely nested simulation
>>>
>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>
>>>
>>>
>>
>
>

On 6/11/2021 9:26 AM, Richard Damon wrote:
> On 6/11/21 10:03 AM, olcott wrote:
>> On 6/11/2021 5:27 AM, Richard Damon wrote:
>>> On 6/10/21 10:56 PM, olcott wrote:
>>>> 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.
>>>
>>> SO you accept that Linz is RIGHT. That there IS no halt decider that can
>>> always give a correct answer to the REAL halting problem definiton.
>>>
>>>>
>>>> This problem is overcome on the basis that the halt decider aborts its
>>>> simulation of this input before ever returning any value. It aborts the
>>>> simulation of its input on the basis that its input specifies what is
>>>> essentially infinite recursion to any simulating halt decider.
>>>
>>>
>>> But, aborting the simulation doesn't actually show anything about the
>>> actual problem. Since the Simulating Halt Decider returns its answer to
>>> its caller (or it fails to be a halt decider) it still is in the
>>> cundundrum that whatever answer it gives will still be wrong.
>>>
>>
>> void Infinite_Loop()
>> {
>>   HERE: goto HERE;
>> }
>>
>> int Infinite_Recursion(u32 N)
>> {
>>   u32 M = Infinite_Recursion(N);
>>   return M;
>> }
>>
>> void H_Hat(u32 P)
>> {
>>   u32 Input_Halts = H(P, P);
>>   if (Input_Halts)
>>     HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>   u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>   Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>
>>   u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>>   Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>>
>>   u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>>   Output("Input_Would_Halt6 = ", Input_Would_Halt6);
>> }
>>
>> In all three of the above cases H must abort the simulation
>> of its input and report that its input does not halt.
>
> WRONG QUESTION.
>
> In th 3rd case, yes, for H to be able to return an answer, it must abort
> the simulation, but the answer of non-halting is wrong.
A computation that forced to halt because its simulation was aborted
does not count as a computation that halts, otherwise infinite loops
would be considered computations that halt.

This is either beyond your intellectual capacity or it is beyond your
ability to pay attention.

When-so-ever any input P to a simulating halt decider H would never halt
unless the simulation of P is aborted H stops simulating P and correctly
decides that P is not a computation that halts.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 10:41 AM, olcott wrote:
> On 6/11/2021 9:26 AM, Richard Damon wrote:
>> On 6/11/21 10:03 AM, olcott wrote:
>>> On 6/11/2021 5:27 AM, Richard Damon wrote:
>>>> On 6/10/21 10:56 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> SO you accept that Linz is RIGHT. That there IS no halt decider that
>>>> can
>>>> always give a correct answer to the REAL halting problem definiton.
>>>>
>>>>>
>>>>> This problem is overcome on the basis that the halt decider aborts its
>>>>> simulation of this input before ever returning any value. It aborts
>>>>> the
>>>>> simulation of its input on the basis that its input specifies what is
>>>>> essentially infinite recursion to any simulating halt decider.
>>>>
>>>>
>>>> But, aborting the simulation doesn't actually show anything about the
>>>> actual problem. Since the Simulating Halt Decider returns its answer to
>>>> its caller (or it fails to be a halt decider) it still is in the
>>>> cundundrum that whatever answer it gives will still be wrong.
>>>>
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> int Infinite_Recursion(u32 N)
>>> {
>>>    u32 M = Infinite_Recursion(N);
>>>    return M;
>>> }
>>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Input_Halts = H(P, P);
>>>    if (Input_Halts)
>>>      HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>    u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>    Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>
>>>    u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>>>    Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>>>
>>>    u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>>>    Output("Input_Would_Halt6 = ", Input_Would_Halt6);
>>> }
>>>
>>> In all three of the above cases H must abort the simulation
>>> of its input and report that its input does not halt.
>>
>> WRONG QUESTION.
>>
>> In th 3rd case, yes, for H to be able to return an answer, it must abort
>> the simulation, but the answer of non-halting is wrong.
> A computation that forced to halt because its simulation was aborted
> does not count as a computation that halts, otherwise infinite loops
> would be considered computations that halt.

But you are confusing the computations, and refusing to look at the case
referenced in the definition where we actually run H_Hat, not just
decide on it. THIS is the run that matters, and THIS run is NEVER
aborted by a simulation, since it is not being run as a simulation.

A computation that is forced to halt because its simulation was aborted
tells you NOTHING by itself if the computation was Halting or
Non-Halting, you just know it hasn't halted YET.

>
> This is either beyond your intellectual capacity or it is beyond your
> ability to pay attention.
>
> When-so-ever any input P to a simulating halt decider H would never halt
> unless the simulation of P is aborted H stops simulating P and correctly
> decides that P is not a computation that halts.
>

Except that it is shown that with your given definition of H, that H_Hat
WILL HALT if allowed to run to its completion, therefore H's decision to
halt and decide that H_Hat is non-halting is incorrect. A Correct
decider on H_Hat could continue to run the simulation of H_Hat and would
see it halting. Thus H was incorrect in its decision to abort.

Yes, H_Hat only halts because the copy of H it contains incorrectly
decides to terminate the simulation of its copy of H_Hat, but that is
the H that the H_Hat is built on. The fact that the H was wrong doesn't
affect the definition of Halting for H_Hat.

You seem to be intellectually unable to handle that deciders CAN be wrong.

Maybe the big issue is you can't keep enough things separate in your
mind. The biggest issue is that when testing if H has given the right
answer, the FULL code of H_Hat must be considered fixed, and that
includes its copy of H (and to be built right, it does have its own
copy). That copy of H is allowed to be (and in fact will always be)
wrong in its determination, as it will be what it is programmed to do.

A computation is ALWAYS defined as a methodical algorithm to get to the
answer. A definition like 'the right answer' is NOT acceptable. When
designing the computation that might be the question that you are trying
to answer, but the key is figuring out how to get there.

We have the basic software principle:

You start with a specification which often desribe what the answer
should be or the properties of that answer (like H should say if P(I) is
a halting computation or not).

It is the job of the programmer to figure out an algorithm to convert
that specification into actual code, and rarely is the specification
directly usable as actual code (if it was, they wouldn't need to hire you).

After the program is coded, you then need to test actually TEST the code
and make sure that the code always generates that right answer, and to
do that you need to go back to the specifications.

Unless you write real bad code, the code will always do what it is coded
to do, but the key is was it coded to do what it was supposed to.

Thus the real test is not does the code do what my algorithm said it
should do (though that is important) it is did it meet the specifications.

For the Halting Problem, the specifications refer to the running of the
code as an independent machine, NOT running it as an input to some halt
decider. Thus the test is ALWAYS to the original machine.

You also need to remember that not all problems are solvable, sometimes
people want somethng that can't be done. In this case, sometimes it can
make sense to figure out it there IS something that is doable that is
'good enough', but sometimes it is better to just admit that it can't be
done.

As an example, you make an algorithm to try to figure a betting stragy
to long term always win at roulette. We know that due to the house cut,
this can't be done. But many people lose their shirt because the come up
with an answer that maybe 90% of the time will win them $100, and the
ignore that 10% of the time they will lose $1500. Maybe they improve it
to win 99% of the time, but now 1% of the time they lose $20,000 and
they think they did better, but it actually got worse long term.

On 6/11/2021 10:32 AM, Richard Damon wrote:
> On 6/11/21 10:41 AM, olcott wrote:
>> On 6/11/2021 9:26 AM, Richard Damon wrote:
>>> On 6/11/21 10:03 AM, olcott wrote:
>>>> On 6/11/2021 5:27 AM, Richard Damon wrote:
>>>>> On 6/10/21 10:56 PM, olcott wrote:
>>>>>> 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.
>>>>>
>>>>> SO you accept that Linz is RIGHT. That there IS no halt decider that
>>>>> can
>>>>> always give a correct answer to the REAL halting problem definiton.
>>>>>
>>>>>>
>>>>>> This problem is overcome on the basis that the halt decider aborts its
>>>>>> simulation of this input before ever returning any value. It aborts
>>>>>> the
>>>>>> simulation of its input on the basis that its input specifies what is
>>>>>> essentially infinite recursion to any simulating halt decider.
>>>>>
>>>>>
>>>>> But, aborting the simulation doesn't actually show anything about the
>>>>> actual problem. Since the Simulating Halt Decider returns its answer to
>>>>> its caller (or it fails to be a halt decider) it still is in the
>>>>> cundundrum that whatever answer it gives will still be wrong.
>>>>>
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>>
>>>> int Infinite_Recursion(u32 N)
>>>> {
>>>>    u32 M = Infinite_Recursion(N);
>>>>    return M;
>>>> }
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>>    u32 Input_Halts = H(P, P);
>>>>    if (Input_Halts)
>>>>      HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>>    Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>>
>>>>    u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>>>>    Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>>>>
>>>>    u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>>>>    Output("Input_Would_Halt6 = ", Input_Would_Halt6);
>>>> }
>>>>
>>>> In all three of the above cases H must abort the simulation
>>>> of its input and report that its input does not halt.
>>>
>>> WRONG QUESTION.
>>>
>>> In th 3rd case, yes, for H to be able to return an answer, it must abort
>>> the simulation, but the answer of non-halting is wrong.
>> A computation that forced to halt because its simulation was aborted
>> does not count as a computation that halts, otherwise infinite loops
>> would be considered computations that halt.
>
> But you are confusing the computations, and refusing to look at the case
> referenced in the definition where we actually run H_Hat, not just
> decide on it. THIS is the run that matters, and THIS run is NEVER
> aborted by a simulation, since it is not being run as a simulation.
>

You have to go through the steps of my proof in mandatory prerequisite
order. At this point I find this to be simply dishonest.

> A computation that is forced to halt because its simulation was aborted
> tells you NOTHING by itself if the computation was Halting or
> Non-Halting, you just know it hasn't halted YET.

You can't even get my freaking words correctly. At this point I also
find that this is simply flat out dishonest.

When-so-ever any input P to a simulating halt decider H would never halt
unless the simulation of P is aborted H stops simulating P and correctly
decides that P is not a computation that halts.

--
Copyright 2021 Pete Olcott

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

On Friday, 11 June 2021 at 16:58:50 UTC+1, olcott wrote:
> On 6/11/2021 10:32 AM, Richard Damon wrote:
> > On 6/11/21 10:41 AM, olcott wrote:
> >> On 6/11/2021 9:26 AM, Richard Damon wrote:
> >>> On 6/11/21 10:03 AM, olcott wrote:
> >>>> On 6/11/2021 5:27 AM, Richard Damon wrote:
> >>>>> On 6/10/21 10:56 PM, olcott wrote:
> >>>>>> 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.
> >>>>>
> >>>>> SO you accept that Linz is RIGHT. That there IS no halt decider that
> >>>>> can
> >>>>> always give a correct answer to the REAL halting problem definiton.
> >>>>>
> >>>>>>
> >>>>>> This problem is overcome on the basis that the halt decider aborts its
> >>>>>> simulation of this input before ever returning any value. It aborts
> >>>>>> the
> >>>>>> simulation of its input on the basis that its input specifies what is
> >>>>>> essentially infinite recursion to any simulating halt decider.
> >>>>>
> >>>>>
> >>>>> But, aborting the simulation doesn't actually show anything about the
> >>>>> actual problem. Since the Simulating Halt Decider returns its answer to
> >>>>> its caller (or it fails to be a halt decider) it still is in the
> >>>>> cundundrum that whatever answer it gives will still be wrong.
> >>>>>
> >>>>
> >>>> void Infinite_Loop()
> >>>> {
> >>>> HERE: goto HERE;
> >>>> }
> >>>>
> >>>> int Infinite_Recursion(u32 N)
> >>>> {
> >>>> u32 M = Infinite_Recursion(N);
> >>>> return M;
> >>>> }
> >>>>
> >>>> void H_Hat(u32 P)
> >>>> {
> >>>> u32 Input_Halts = H(P, P);
> >>>> if (Input_Halts)
> >>>> HERE: goto HERE;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
> >>>> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
> >>>>
> >>>> u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
> >>>> Output("Input_Would_Halt3 = ", Input_Would_Halt3);
> >>>>
> >>>> u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
> >>>> Output("Input_Would_Halt6 = ", Input_Would_Halt6);
> >>>> }
> >>>>
> >>>> In all three of the above cases H must abort the simulation
> >>>> of its input and report that its input does not halt.
> >>>
> >>> WRONG QUESTION.
> >>>
> >>> In th 3rd case, yes, for H to be able to return an answer, it must abort
> >>> the simulation, but the answer of non-halting is wrong.
> >> A computation that forced to halt because its simulation was aborted
> >> does not count as a computation that halts, otherwise infinite loops
> >> would be considered computations that halt.
> >
> > But you are confusing the computations, and refusing to look at the case
> > referenced in the definition where we actually run H_Hat, not just
> > decide on it. THIS is the run that matters, and THIS run is NEVER
> > aborted by a simulation, since it is not being run as a simulation.
> >
> You have to go through the steps of my proof in mandatory prerequisite
> order. At this point I find this to be simply dishonest.
> > A computation that is forced to halt because its simulation was aborted
> > tells you NOTHING by itself if the computation was Halting or
> > Non-Halting, you just know it hasn't halted YET.
> You can't even get my freaking words correctly. At this point I also
> find that this is simply flat out dishonest.
> When-so-ever any input P to a simulating halt decider H would never halt
> unless the simulation of P is aborted H stops simulating P and correctly
> decides that P is not a computation that halts.
>
Yes, but the point is that the simulating halt decider is simulating a simulating
halt decider.

On 6/11/2021 11:27 AM, Malcolm McLean wrote:
> On Friday, 11 June 2021 at 16:58:50 UTC+1, olcott wrote:
>> On 6/11/2021 10:32 AM, Richard Damon wrote:
>>> On 6/11/21 10:41 AM, olcott wrote:
>>>> On 6/11/2021 9:26 AM, Richard Damon wrote:
>>>>> On 6/11/21 10:03 AM, olcott wrote:
>>>>>> On 6/11/2021 5:27 AM, Richard Damon wrote:
>>>>>>> On 6/10/21 10:56 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>
>>>>>>> SO you accept that Linz is RIGHT. That there IS no halt decider that
>>>>>>> can
>>>>>>> always give a correct answer to the REAL halting problem definiton.
>>>>>>>
>>>>>>>>
>>>>>>>> This problem is overcome on the basis that the halt decider aborts its
>>>>>>>> simulation of this input before ever returning any value. It aborts
>>>>>>>> the
>>>>>>>> simulation of its input on the basis that its input specifies what is
>>>>>>>> essentially infinite recursion to any simulating halt decider.
>>>>>>>
>>>>>>>
>>>>>>> But, aborting the simulation doesn't actually show anything about the
>>>>>>> actual problem. Since the Simulating Halt Decider returns its answer to
>>>>>>> its caller (or it fails to be a halt decider) it still is in the
>>>>>>> cundundrum that whatever answer it gives will still be wrong.
>>>>>>>
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int Infinite_Recursion(u32 N)
>>>>>> {
>>>>>> u32 M = Infinite_Recursion(N);
>>>>>> return M;
>>>>>> }
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>> u32 Input_Halts = H(P, P);
>>>>>> if (Input_Halts)
>>>>>> HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>>>> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>>>>
>>>>>> u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>>>>>> Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>>>>>>
>>>>>> u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>>>>>> Output("Input_Would_Halt6 = ", Input_Would_Halt6);
>>>>>> }
>>>>>>
>>>>>> In all three of the above cases H must abort the simulation
>>>>>> of its input and report that its input does not halt.
>>>>>
>>>>> WRONG QUESTION.
>>>>>
>>>>> In th 3rd case, yes, for H to be able to return an answer, it must abort
>>>>> the simulation, but the answer of non-halting is wrong.
>>>> A computation that forced to halt because its simulation was aborted
>>>> does not count as a computation that halts, otherwise infinite loops
>>>> would be considered computations that halt.
>>>
>>> But you are confusing the computations, and refusing to look at the case
>>> referenced in the definition where we actually run H_Hat, not just
>>> decide on it. THIS is the run that matters, and THIS run is NEVER
>>> aborted by a simulation, since it is not being run as a simulation.
>>>
>> You have to go through the steps of my proof in mandatory prerequisite
>> order. At this point I find this to be simply dishonest.
>>> A computation that is forced to halt because its simulation was aborted
>>> tells you NOTHING by itself if the computation was Halting or
>>> Non-Halting, you just know it hasn't halted YET.
>> You can't even get my freaking words correctly. At this point I also
>> find that this is simply flat out dishonest.
>> When-so-ever any input P to a simulating halt decider H would never halt
>> unless the simulation of P is aborted H stops simulating P and correctly
>> decides that P is not a computation that halts.
>>
> Yes, but the point is that the simulating halt decider is simulating a simulating
> halt decider.
>

So what? The above halt deciding principle is correct under all possible
conditions as long as its criteria is met: (the input would never halt
unless its simulation is aborted).

--
Copyright 2021 Pete Olcott

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

On 6/11/21 11:58 AM, olcott wrote:
> On 6/11/2021 10:32 AM, Richard Damon wrote:
>> On 6/11/21 10:41 AM, olcott wrote:
>>> On 6/11/2021 9:26 AM, Richard Damon wrote:
>>>> On 6/11/21 10:03 AM, olcott wrote:
>>>>> On 6/11/2021 5:27 AM, Richard Damon wrote:
>>>>>> On 6/10/21 10:56 PM, olcott wrote:
>>>>>>> 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.
>>>>>>
>>>>>> SO you accept that Linz is RIGHT. That there IS no halt decider that
>>>>>> can
>>>>>> always give a correct answer to the REAL halting problem definiton.
>>>>>>
>>>>>>>
>>>>>>> This problem is overcome on the basis that the halt decider
>>>>>>> aborts its
>>>>>>> simulation of this input before ever returning any value. It aborts
>>>>>>> the
>>>>>>> simulation of its input on the basis that its input specifies
>>>>>>> what is
>>>>>>> essentially infinite recursion to any simulating halt decider.
>>>>>>
>>>>>>
>>>>>> But, aborting the simulation doesn't actually show anything about the
>>>>>> actual problem. Since the Simulating Halt Decider returns its
>>>>>> answer to
>>>>>> its caller (or it fails to be a halt decider) it still is in the
>>>>>> cundundrum that whatever answer it gives will still be wrong.
>>>>>>
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>>     HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int Infinite_Recursion(u32 N)
>>>>> {
>>>>>     u32 M = Infinite_Recursion(N);
>>>>>     return M;
>>>>> }
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>>     u32 Input_Halts = H(P, P);
>>>>>     if (Input_Halts)
>>>>>       HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>>>     Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>>>
>>>>>     u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>>>>>     Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>>>>>
>>>>>     u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>>>>>     Output("Input_Would_Halt6 = ", Input_Would_Halt6);
>>>>> }
>>>>>
>>>>> In all three of the above cases H must abort the simulation
>>>>> of its input and report that its input does not halt.
>>>>
>>>> WRONG QUESTION.
>>>>
>>>> In th 3rd case, yes, for H to be able to return an answer, it must
>>>> abort
>>>> the simulation, but the answer of non-halting is wrong.
>>> A computation that forced to halt because its simulation was aborted
>>> does not count as a computation that halts, otherwise infinite loops
>>> would be considered computations that halt.
>>
>> But you are confusing the computations, and refusing to look at the case
>> referenced in the definition where we actually run H_Hat, not just
>> decide on it. THIS is the run that matters, and THIS run is NEVER
>> aborted by a simulation, since it is not being run as a simulation.
>>
>
> You have to go through the steps of my proof in mandatory prerequisite
> order. At this point I find this to be simply dishonest.

WHAT proof. We have been following and you just jumped and made the
claim that H is right on H_Hat by similarity to two very different
machines. A PROOF, starts with well accepted statements and definitions,
and show via logicial necessity that some other statement is true.

For example:
Black Cats are Black.
Felix is a Black Cat.
Therefore Felix is Black.

Is a proper (though somewhat trivial proof).

You just made a statement, and IT IS WRONG.

BY DEFINITION, A Halting Computation is a computation that finishes in
finite time. H_Hat(H_Hat) finishes in finite time, in part because the
copy of H it contains will abort a simulation of a copy of the
description of H_Hat(H_Hat), but that doesn't affect the actual
definition of halting, it doesn't matter why a computation completes,
just that it does. (NOTE, this is the MACHINE ITSELF, it does NOT say
that aborting a simulation means the simulated machine is halting, it
never finished its computation to its halt).

>
>> A computation that is forced to halt because its simulation was aborted
>> tells you NOTHING by itself if the computation was Halting or
>> Non-Halting, you just know it hasn't halted YET.
>
> You can't even get my freaking words correctly. At this point I also
> find that this is simply flat out dishonest.

>
> When-so-ever any input P to a simulating halt decider H would never halt
> unless the simulation of P is aborted H stops simulating P and correctly
> decides that P is not a computation that halts.
>

FALSE STATEMENT. Pulled out out thin air without proof.

Counter example showing it is wrong, H_Hat built on your H that does
decide to abort the simulation.

Even you have provided traces of this case, which clearly shows that
H_Hat(H_Hat) in this case, when run as the top level machine DOES finish
and come to a halt, and thus by the DEFINITION of Halting is a Halting
Computation. This statement says (at least by your interpretation) that
it is correctly decided as non-halting, and non-halting is NOT Halting,
and thus wrong.

Please correct what you claim to be a ACTUAL error in that statement.

Any statement claiming something to always be true that has at least one
counter example is a false statement, therefore this statement is false.

Reason it is false, under your interpretation of the operation you
conflate the fixed operation of the H included by copy inside H_Hat with
the testing of the decision process of the outer deciding H.

We can test the 'would never halt' clause of you statement by changing
the OUTER H to a pure simulator. When we do this we do NOT change the
copy of H that is inside H_Hat, as that is a different piece of code
that is part of the input, we want to test if H gave the right answer
for a GIVEN input, so we don't change it.

WHen we make that change, we see that the simulation will end, and thus
the requitment of would never halt unless the simulation of P is
aborted, is NOT true.

Note, a big part of your error is that you don't seem to understand that
the way Turing Machines are built, the machine H_Hat includes a COPY of
H, and is not defined to use the H that is calling it (and in fact, by
the rules of computations, you can NOT define such a machine as a
computation). Since H_Hat has its own copy of H, the change we make to H
to test if it actually needed to do the termination of the simulation
that it has been programmed to do, doesn't affect the copy in H_Hat.

You don't seem to be able to understand this basic principle of
computing. I don't think you really understand much about Turing
Machines, and have gotten in over your head.

On 6/11/2021 11:50 AM, Richard Damon wrote:
> On 6/11/21 11:58 AM, olcott wrote:
>> On 6/11/2021 10:32 AM, Richard Damon wrote:
>>> On 6/11/21 10:41 AM, olcott wrote:
>>>> On 6/11/2021 9:26 AM, Richard Damon wrote:
>>>>> On 6/11/21 10:03 AM, olcott wrote:
>>>>>> On 6/11/2021 5:27 AM, Richard Damon wrote:
>>>>>>> On 6/10/21 10:56 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>
>>>>>>> SO you accept that Linz is RIGHT. That there IS no halt decider that
>>>>>>> can
>>>>>>> always give a correct answer to the REAL halting problem definiton.
>>>>>>>
>>>>>>>>
>>>>>>>> This problem is overcome on the basis that the halt decider
>>>>>>>> aborts its
>>>>>>>> simulation of this input before ever returning any value. It aborts
>>>>>>>> the
>>>>>>>> simulation of its input on the basis that its input specifies
>>>>>>>> what is
>>>>>>>> essentially infinite recursion to any simulating halt decider.
>>>>>>>
>>>>>>>
>>>>>>> But, aborting the simulation doesn't actually show anything about the
>>>>>>> actual problem. Since the Simulating Halt Decider returns its
>>>>>>> answer to
>>>>>>> its caller (or it fails to be a halt decider) it still is in the
>>>>>>> cundundrum that whatever answer it gives will still be wrong.
>>>>>>>
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>>     HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int Infinite_Recursion(u32 N)
>>>>>> {
>>>>>>     u32 M = Infinite_Recursion(N);
>>>>>>     return M;
>>>>>> }
>>>>>>
>>>>>> void H_Hat(u32 P)
>>>>>> {
>>>>>>     u32 Input_Halts = H(P, P);
>>>>>>     if (Input_Halts)
>>>>>>       HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>     u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
>>>>>>     Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>>>>>>
>>>>>>     u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
>>>>>>     Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>>>>>>
>>>>>>     u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
>>>>>>     Output("Input_Would_Halt6 = ", Input_Would_Halt6);
>>>>>> }
>>>>>>
>>>>>> In all three of the above cases H must abort the simulation
>>>>>> of its input and report that its input does not halt.
>>>>>
>>>>> WRONG QUESTION.
>>>>>
>>>>> In th 3rd case, yes, for H to be able to return an answer, it must
>>>>> abort
>>>>> the simulation, but the answer of non-halting is wrong.
>>>> A computation that forced to halt because its simulation was aborted
>>>> does not count as a computation that halts, otherwise infinite loops
>>>> would be considered computations that halt.
>>>
>>> But you are confusing the computations, and refusing to look at the case
>>> referenced in the definition where we actually run H_Hat, not just
>>> decide on it. THIS is the run that matters, and THIS run is NEVER
>>> aborted by a simulation, since it is not being run as a simulation.
>>>
>>
>> You have to go through the steps of my proof in mandatory prerequisite
>> order. At this point I find this to be simply dishonest.
>
> WHAT proof. We have been following and you just jumped and made the
> claim that H is right on H_Hat by similarity to two very different
> machines. A PROOF, starts with well accepted statements and definitions,
> and show via logicial necessity that some other statement is true.
>
> For example:
> Black Cats are Black.
> Felix is a Black Cat.
> Therefore Felix is Black.
>
> Is a proper (though somewhat trivial proof).
>
> You just made a statement, and IT IS WRONG.
>
> BY DEFINITION, A Halting Computation is a computation that finishes in
> finite time. H_Hat(H_Hat) finishes in finite time, in part because the
> copy of H it contains will abort a simulation of a copy of the
> description of H_Hat(H_Hat), but that doesn't affect the actual
> definition of halting, it doesn't matter why a computation completes,
> just that it does. (NOTE, this is the MACHINE ITSELF, it does NOT say
> that aborting a simulation means the simulated machine is halting, it
> never finished its computation to its halt).
>
>>
>>> A computation that is forced to halt because its simulation was aborted
>>> tells you NOTHING by itself if the computation was Halting or
>>> Non-Halting, you just know it hasn't halted YET.
>>
>> You can't even get my freaking words correctly. At this point I also
>> find that this is simply flat out dishonest.
>
>
>
>>
>> When-so-ever any input P to a simulating halt decider H would never halt
>> unless the simulation of P is aborted H stops simulating P and correctly
>> decides that P is not a computation that halts.
>>
>
> FALSE STATEMENT. Pulled out out thin air without proof.
>
> Counter example showing it is wrong, H_Hat built on your H that does
> decide to abort the simulation.
>

The above statement can be known to be true entirely on the basis of the
meaning of its words. This is either beyond your intellectual capacity
or you are simply dishonest.

There is no case where the simulation of the input to H(H_Hat, H_Hat)
would ever halt unless this simulation is aborted.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 12:58 PM, olcott wrote:
> On 6/11/2021 11:50 AM, Richard Damon wrote:
>> On 6/11/21 11:58 AM, olcott wrote:
>>>
>>> When-so-ever any input P to a simulating halt decider H would never halt
>>> unless the simulation of P is aborted H stops simulating P and correctly
>>> decides that P is not a computation that halts.
>>>
>>
>> FALSE STATEMENT. Pulled out out thin air without proof.
>>
>> Counter example showing it is wrong, H_Hat built on your H that does
>> decide to abort the simulation.
>>
>
> The above statement can be known to be true entirely on the basis of the
> meaning of its words. This is either beyond your intellectual capacity
> or you are simply dishonest.
>
> There is no case where the simulation of the input to H(H_Hat, H_Hat)
> would ever halt unless this simulation is aborted.
>

It can be show true with a PROPER definition of the words, the key is
that 'the simulation of P is aborted' applies only to that given
simulation, and doesn't include other copies. The fact that H_Hat
includes a copy of H that simulates a copy of H_Hat and aborts its
simulation (incorrectly deciding non-Halting) doesn't make H_Hat
non-halting.

As I have shown, it can be proved FALSE with YOUR (wrong) meaning of the
words.

If something can be shown to be FALSE, it can not be true, unless the
logic system can be shown inconsistent, which as I have pointed out
before, seems to be the state of the system under your definitions.

On 6/11/2021 12:52 PM, Richard Damon wrote:
> On 6/11/21 12:58 PM, olcott wrote:
>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>
>>>> When-so-ever any input P to a simulating halt decider H would never halt
>>>> unless the simulation of P is aborted H stops simulating P and correctly
>>>> decides that P is not a computation that halts.
>>>>
>>>
>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>
>>> Counter example showing it is wrong, H_Hat built on your H that does
>>> decide to abort the simulation.
>>>
>>
>> The above statement can be known to be true entirely on the basis of the
>> meaning of its words. This is either beyond your intellectual capacity
>> or you are simply dishonest.
>>
>> There is no case where the simulation of the input to H(H_Hat, H_Hat)
>> would ever halt unless this simulation is aborted.
>>
>
> It can be show true with a PROPER definition of the words, the key is
> that 'the simulation of P is aborted' applies only to that given
> simulation,

This is probably beyond your capacity to understand:

In the case of infinite recursion the entire invocation sequence is
infinitely recursive. When any single function invocation in this
infinite invocation call chain is terminated then the whole call chain
is terminated.

When the termination of one of these invocations is required to prevent
the infinite execution of this call chain then the entire call chain
represents a computation that does not halt.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 2:47 PM, olcott wrote:
> On 6/11/2021 12:52 PM, Richard Damon wrote:
>> On 6/11/21 12:58 PM, olcott wrote:
>>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>>
>>>>> When-so-ever any input P to a simulating halt decider H would never
>>>>> halt
>>>>> unless the simulation of P is aborted H stops simulating P and
>>>>> correctly
>>>>> decides that P is not a computation that halts.
>>>>>
>>>>
>>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>>
>>>> Counter example showing it is wrong, H_Hat built on your H that does
>>>> decide to abort the simulation.
>>>>
>>>
>>> The above statement can be known to be true entirely on the basis of the
>>> meaning of its words. This is either beyond your intellectual capacity
>>> or you are simply dishonest.
>>>
>>> There is no case where the simulation of the input to H(H_Hat, H_Hat)
>>> would ever halt unless this simulation is aborted.
>>>
>>
>> It can be show true with a PROPER definition of the words, the key is
>> that 'the simulation of P is aborted' applies only to that given
>> simulation,
>
> This is probably beyond your capacity to understand:
>
> In the case of infinite recursion the entire invocation sequence is
> infinitely recursive. When any single function invocation in this
> infinite invocation call chain is terminated then the whole call chain
> is terminated.

WRONG.

If the sequence WAS infinitly recursive, then it could NEVER end, as it
takes infinite time to actually reach infinite recursion.

What we have here is a POTENTIAL infinite recursion, only potential,
because something in the loop has the ability to break that otherwise
potentially infinite recursion, and does exercise that ability. Since it
does we do NOT have an actual infinite recursion and can follow the now
finite execution trace.

>
> When the termination of one of these invocations is required to prevent
> the infinite execution of this call chain then the entire call chain
> represents a computation that does not halt.
>

Wrong, when the actor that has the potential to break the infinite
recursion does act, then it can and does return and that call chain can
finish.

Your argument might apply if the thing terminating the sequence wasn't
part of the recursive loop, then it could possibly conclude (with the
right logic) that nothing in the recursive loop could break the loop and
thus that loop was truely infinitely recursive and thus non-halting.

The fact that in this case H WAS part of the loop, this logic doesn't
hold as we just showed that something in the loop has the power to break
the loop, so the loop was never infinite in the first place. The decider
does run into the issue that having decided to abort a simulation that
it was part of, it needs to figure out what answer it should return. The
trace up to the point of aborting does NOT have enough information to
answer that, as it knows that it has aborted a decider that would given
a bit more time would have aborted things itself, and thus this decide
needs to figure out what would happen after that happens.

The problem is that this is turns out to not be a finitely computable
result in all cases, including the one we are in. The self-reference in
the design of the situation makes it impossible for H to come up with an
answer to give that is consistant.

On 6/11/2021 2:19 PM, Richard Damon wrote:
> On 6/11/21 2:47 PM, olcott wrote:
>> On 6/11/2021 12:52 PM, Richard Damon wrote:
>>> On 6/11/21 12:58 PM, olcott wrote:
>>>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>>>
>>>>>> When-so-ever any input P to a simulating halt decider H would never
>>>>>> halt
>>>>>> unless the simulation of P is aborted H stops simulating P and
>>>>>> correctly
>>>>>> decides that P is not a computation that halts.
>>>>>>
>>>>>
>>>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>>>
>>>>> Counter example showing it is wrong, H_Hat built on your H that does
>>>>> decide to abort the simulation.
>>>>>
>>>>
>>>> The above statement can be known to be true entirely on the basis of the
>>>> meaning of its words. This is either beyond your intellectual capacity
>>>> or you are simply dishonest.
>>>>
>>>> There is no case where the simulation of the input to H(H_Hat, H_Hat)
>>>> would ever halt unless this simulation is aborted.
>>>>
>>>
>>> It can be show true with a PROPER definition of the words, the key is
>>> that 'the simulation of P is aborted' applies only to that given
>>> simulation,
>>
>> This is probably beyond your capacity to understand:
>>
>> In the case of infinite recursion the entire invocation sequence is
>> infinitely recursive. When any single function invocation in this
>> infinite invocation call chain is terminated then the whole call chain
>> is terminated.
>
> WRONG.
>
No sense talking to you anymore. You are either too stupid or dishonest
to understand or acknowledge that a simulating (at least partial) halt
decider does correctly decide that this function <is> infinitely recursive.

int Infinite_Recursion(u32 N)
{ u32 M = Infinite_Recursion(N);
return M;
}

--
Copyright 2021 Pete Olcott

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

On 6/11/21 3:33 PM, olcott wrote:
> On 6/11/2021 2:19 PM, Richard Damon wrote:
>> On 6/11/21 2:47 PM, olcott wrote:
>>> On 6/11/2021 12:52 PM, Richard Damon wrote:
>>>> On 6/11/21 12:58 PM, olcott wrote:
>>>>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>>>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>>>>
>>>>>>> When-so-ever any input P to a simulating halt decider H would never
>>>>>>> halt
>>>>>>> unless the simulation of P is aborted H stops simulating P and
>>>>>>> correctly
>>>>>>> decides that P is not a computation that halts.
>>>>>>>
>>>>>>
>>>>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>>>>
>>>>>> Counter example showing it is wrong, H_Hat built on your H that does
>>>>>> decide to abort the simulation.
>>>>>>
>>>>>
>>>>> The above statement can be known to be true entirely on the basis
>>>>> of the
>>>>> meaning of its words. This is either beyond your intellectual capacity
>>>>> or you are simply dishonest.
>>>>>
>>>>> There is no case where the simulation of the input to H(H_Hat, H_Hat)
>>>>> would ever halt unless this simulation is aborted.
>>>>>
>>>>
>>>> It can be show true with a PROPER definition of the words, the key is
>>>> that 'the simulation of P is aborted' applies only to that given
>>>> simulation,
>>>
>>> This is probably beyond your capacity to understand:
>>>
>>> In the case of infinite recursion the entire invocation sequence is
>>> infinitely recursive. When any single function invocation in this
>>> infinite invocation call chain is terminated then the whole call chain
>>> is terminated.
>>
>> WRONG.
>>
> No sense talking to you anymore. You are either too stupid or dishonest
> to understand or acknowledge that a simulating (at least partial) halt
> decider does correctly decide that this function <is> infinitely recursive.
>
> int Infinite_Recursion(u32 N)
> {
>   u32 M = Infinite_Recursion(N);
>   return M;
> }
>
>

Never said THAT one wasn't. Where did I say THAT one wasn't. You seem to
have an issue with keeping to real facts.

Wrong rules can sometimes get right answers, just as right rules used
wronglycan sometimes get wrong answers.

The issue with your supposed definition is when the simulating halt
decider sees copies of itself, which doesn't happen in that machine.

Maybe YOU should learn to actually read what was said and not say such
dumb things.

On 6/11/2021 3:15 PM, Richard Damon wrote:
> On 6/11/21 3:33 PM, olcott wrote:
>> On 6/11/2021 2:19 PM, Richard Damon wrote:
>>> On 6/11/21 2:47 PM, olcott wrote:
>>>> On 6/11/2021 12:52 PM, Richard Damon wrote:
>>>>> On 6/11/21 12:58 PM, olcott wrote:
>>>>>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>>>>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>>>>>
>>>>>>>> When-so-ever any input P to a simulating halt decider H would never
>>>>>>>> halt
>>>>>>>> unless the simulation of P is aborted H stops simulating P and
>>>>>>>> correctly
>>>>>>>> decides that P is not a computation that halts.
>>>>>>>>
>>>>>>>
>>>>>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>>>>>
>>>>>>> Counter example showing it is wrong, H_Hat built on your H that does
>>>>>>> decide to abort the simulation.
>>>>>>>
>>>>>>
>>>>>> The above statement can be known to be true entirely on the basis
>>>>>> of the
>>>>>> meaning of its words. This is either beyond your intellectual capacity
>>>>>> or you are simply dishonest.
>>>>>>
>>>>>> There is no case where the simulation of the input to H(H_Hat, H_Hat)
>>>>>> would ever halt unless this simulation is aborted.
>>>>>>
>>>>>
>>>>> It can be show true with a PROPER definition of the words, the key is
>>>>> that 'the simulation of P is aborted' applies only to that given
>>>>> simulation,
>>>>
>>>> This is probably beyond your capacity to understand:
>>>>
>>>> In the case of infinite recursion the entire invocation sequence is
>>>> infinitely recursive. When any single function invocation in this
>>>> infinite invocation call chain is terminated then the whole call chain
>>>> is terminated.
>>>
>>> WRONG.
>>>
>> No sense talking to you anymore. You are either too stupid or dishonest
>> to understand or acknowledge that a simulating (at least partial) halt
>> decider does correctly decide that this function <is> infinitely recursive.
>>
>> int Infinite_Recursion(u32 N)
>> {
>>   u32 M = Infinite_Recursion(N);
>>   return M;
>> }
>>
>>
>
> Never said THAT one wasn't. Where did I say THAT one wasn't. You seem to
> have an issue with keeping to real facts.
>
> Wrong rules can sometimes get right answers, just as right rules used
> wronglycan sometimes get wrong answers.
>
> The issue with your supposed definition is when the simulating halt
> decider sees copies of itself, which doesn't happen in that machine.
>
> Maybe YOU should learn to actually read what was said and not say such
> dumb things.
>

I have been trying to get you to understand that H does correctly decide
that Infinite_Recursion() does not halt for about 15 messages now.

So are so damned evasive that this is getting to be more work than it is
worth.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 4:42 PM, olcott wrote:
> On 6/11/2021 3:15 PM, Richard Damon wrote:
>> On 6/11/21 3:33 PM, olcott wrote:
>>> On 6/11/2021 2:19 PM, Richard Damon wrote:
>>>> On 6/11/21 2:47 PM, olcott wrote:
>>>>> On 6/11/2021 12:52 PM, Richard Damon wrote:
>>>>>> On 6/11/21 12:58 PM, olcott wrote:
>>>>>>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>>>>>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>> When-so-ever any input P to a simulating halt decider H would
>>>>>>>>> never
>>>>>>>>> halt
>>>>>>>>> unless the simulation of P is aborted H stops simulating P and
>>>>>>>>> correctly
>>>>>>>>> decides that P is not a computation that halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>>>>>>
>>>>>>>> Counter example showing it is wrong, H_Hat built on your H that
>>>>>>>> does
>>>>>>>> decide to abort the simulation.
>>>>>>>>
>>>>>>>
>>>>>>> The above statement can be known to be true entirely on the basis
>>>>>>> of the
>>>>>>> meaning of its words. This is either beyond your intellectual
>>>>>>> capacity
>>>>>>> or you are simply dishonest.
>>>>>>>
>>>>>>> There is no case where the simulation of the input to H(H_Hat,
>>>>>>> H_Hat)
>>>>>>> would ever halt unless this simulation is aborted.
>>>>>>>
>>>>>>
>>>>>> It can be show true with a PROPER definition of the words, the key is
>>>>>> that 'the simulation of P is aborted' applies only to that given
>>>>>> simulation,
>>>>>
>>>>> This is probably beyond your capacity to understand:
>>>>>
>>>>> In the case of infinite recursion the entire invocation sequence is
>>>>> infinitely recursive. When any single function invocation in this
>>>>> infinite invocation call chain is terminated then the whole call chain
>>>>> is terminated.
>>>>
>>>> WRONG.
>>>>
>>> No sense talking to you anymore. You are either too stupid or dishonest
>>> to understand or acknowledge that a simulating (at least partial) halt
>>> decider does correctly decide that this function <is> infinitely
>>> recursive.
>>>
>>> int Infinite_Recursion(u32 N)
>>> {
>>>    u32 M = Infinite_Recursion(N);
>>>    return M;
>>> }
>>>
>>>
>>
>> Never said THAT one wasn't. Where did I say THAT one wasn't. You seem to
>> have an issue with keeping to real facts.
>>
>> Wrong rules can sometimes get right answers, just as right rules used
>> wronglycan sometimes get wrong answers.
>>
>> The issue with your supposed definition is when the simulating halt
>> decider sees copies of itself, which doesn't happen in that machine.
>>
>> Maybe YOU should learn to actually read what was said and not say such
>> dumb things.
>>
>
> I have been trying to get you to understand that H does correctly decide
> that Infinite_Recursion() does not halt for about 15 messages now.
>
> So are so damned evasive that this is getting to be more work than it is
> worth.
>

And I have NEVER said it didn't. When you quote the RULE, I object to it
as the rule can be wrong for cases like H_Hat, but a wrong rule can get
some cases right.

This whole thread started with your message
Message-ID: <C6Gdndon-KXY8F79nZ2dnUU7-WfNnZ2d@giganews.com>
Date: Fri, 11 Jun 2021 09:03:52 -0500

where you stated:
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> int Infinite_Recursion(u32 N)
> {
> u32 M = Infinite_Recursion(N);
> return M;
> }
>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = H(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
> int main()
> {
> u32 Input_Would_Halt2 = H((u32)Infinite_Loop, (u32)Infinite_Loop);
> Output("Input_Would_Halt2 = ", Input_Would_Halt2);
>
> u32 Input_Would_Halt3 = H((u32)Infinite_Recursion, 3);
> Output("Input_Would_Halt3 = ", Input_Would_Halt3);
>
> u32 Input_Would_Halt6 = H((u32)H_Hat, (u32)H_Hat);
> Output("Input_Would_Halt6 = ", Input_Would_Halt6);
> }
>
> In all three of the above cases H must abort the simulation
> of its input and report that its input does not halt.

And I objected to your claim that the last was decided correctly as
non-halting since H_Hat(H_Hat) does halt and thus the non-halting answer
is incorrect.

If YOU can't keep straight what is being discussed, maybe you need to
see someone to have your meds adjusted.

The fact that you keep on defending ground that isn't being attacked is
signs that you aren't thinking well.

On 6/11/2021 3:57 PM, Richard Damon wrote:
> On 6/11/21 4:42 PM, olcott wrote:
>> On 6/11/2021 3:15 PM, Richard Damon wrote:
>>> On 6/11/21 3:33 PM, olcott wrote:
>>>> On 6/11/2021 2:19 PM, Richard Damon wrote:
>>>>> On 6/11/21 2:47 PM, olcott wrote:
>>>>>> On 6/11/2021 12:52 PM, Richard Damon wrote:
>>>>>>> On 6/11/21 12:58 PM, olcott wrote:
>>>>>>>> On 6/11/2021 11:50 AM, Richard Damon wrote:
>>>>>>>>> On 6/11/21 11:58 AM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> When-so-ever any input P to a simulating halt decider H would
>>>>>>>>>> never
>>>>>>>>>> halt
>>>>>>>>>> unless the simulation of P is aborted H stops simulating P and
>>>>>>>>>> correctly
>>>>>>>>>> decides that P is not a computation that halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> FALSE STATEMENT. Pulled out out thin air without proof.
>>>>>>>>>
>>>>>>>>> Counter example showing it is wrong, H_Hat built on your H that
>>>>>>>>> does
>>>>>>>>> decide to abort the simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The above statement can be known to be true entirely on the basis
>>>>>>>> of the
>>>>>>>> meaning of its words. This is either beyond your intellectual
>>>>>>>> capacity
>>>>>>>> or you are simply dishonest.
>>>>>>>>
>>>>>>>> There is no case where the simulation of the input to H(H_Hat,
>>>>>>>> H_Hat)
>>>>>>>> would ever halt unless this simulation is aborted.
>>>>>>>>
>>>>>>>
>>>>>>> It can be show true with a PROPER definition of the words, the key is
>>>>>>> that 'the simulation of P is aborted' applies only to that given
>>>>>>> simulation,
>>>>>>
>>>>>> This is probably beyond your capacity to understand:
>>>>>>
>>>>>> In the case of infinite recursion the entire invocation sequence is
>>>>>> infinitely recursive. When any single function invocation in this
>>>>>> infinite invocation call chain is terminated then the whole call chain
>>>>>> is terminated.
>>>>>
>>>>> WRONG.
>>>>>
>>>> No sense talking to you anymore. You are either too stupid or dishonest
>>>> to understand or acknowledge that a simulating (at least partial) halt
>>>> decider does correctly decide that this function <is> infinitely
>>>> recursive.
>>>>
>>>> int Infinite_Recursion(u32 N)
>>>> {
>>>>    u32 M = Infinite_Recursion(N);
>>>>    return M;
>>>> }
>>>>
>>>>
>>>
>>> Never said THAT one wasn't. Where did I say THAT one wasn't. You seem to
>>> have an issue with keeping to real facts.
>>>
>>> Wrong rules can sometimes get right answers, just as right rules used
>>> wronglycan sometimes get wrong answers.
>>>
>>> The issue with your supposed definition is when the simulating halt
>>> decider sees copies of itself, which doesn't happen in that machine.
>>>
>>> Maybe YOU should learn to actually read what was said and not say such
>>> dumb things.
>>>
>>
>> I have been trying to get you to understand that H does correctly decide
>> that Infinite_Recursion() does not halt for about 15 messages now.
>>
>> So are so damned evasive that this is getting to be more work than it is
>> worth.
>>
>
> And I have NEVER said it didn't. When you quote the RULE, I object to it
> as the rule can be wrong for cases like H_Hat, but a wrong rule can get
> some cases right.
So you agree with this:
When-so-ever an input demonstrates an infinitely repeating pattern and
this repeating pattern is caused by an infinite loop or infinite
recursion then the simulating halt decider can stop simulating its input
and report that this input does not halt.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 5:07 PM, olcott wrote:
> On 6/11/2021 3:57 PM, Richard Damon wrote:
>>
>> And I have NEVER said it didn't. When you quote the RULE, I object to it
>> as the rule can be wrong for cases like H_Hat, but a wrong rule can get
>> some cases right.
> So you agree with this:
> When-so-ever an input demonstrates an infinitely repeating pattern and
> this repeating pattern is caused by an infinite loop or infinite
> recursion then the simulating halt decider can stop simulating its input
> and report that this input does not halt.
>

If it si TRUELY an infinitely repeating pattern with no possible break,
then the decider can stop the simulation and report not-halitng.

Note, if it sees a decider in the loop, then it needs to allow for the
action of the decider. This is where you fail for H_Hat.

On 6/11/2021 4:38 PM, Richard Damon wrote:
> On 6/11/21 5:07 PM, olcott wrote:
>> On 6/11/2021 3:57 PM, Richard Damon wrote:
>>>
>>> And I have NEVER said it didn't. When you quote the RULE, I object to it
>>> as the rule can be wrong for cases like H_Hat, but a wrong rule can get
>>> some cases right.
>> So you agree with this:
>> When-so-ever an input demonstrates an infinitely repeating pattern and
>> this repeating pattern is caused by an infinite loop or infinite
>> recursion then the simulating halt decider can stop simulating its input
>> and report that this input does not halt.
>>
>
> If it si TRUELY an infinitely repeating pattern with no possible break,
> then the decider can stop the simulation and report not-halitng.
>
> Note, if it sees a decider in the loop, then it needs to allow for the
> action of the decider. This is where you fail for H_Hat.
>

We can artificially contrive an undecidable problem depending on how we
frame the problem or we can remove this artificial contrivance.

It is self-evident that any computation that will never halt unless its
simulation is aborted is merely a computationally equivalent way to
define that a computation does not halt.

We know this on the basis that a UTM simulation of a TM description ⟨P⟩
that does not halt logically entails that the TM P does not halt.

A simulating halt decider applies this computationally equivalent
definition of non-halting does correctly decide that both the pseudo-code

procedure compute_g(i):
if f(i, i) == 0 then
return 0
else
loop forever // (Wikipedia:Halting Problem)

and the Linz Ĥ

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
if M applied to wM halts, and

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
if M applied to wM does not halt

counter-examples are merely computations that do not halt on their input.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 6:17 PM, olcott wrote:
> On 6/11/2021 4:38 PM, Richard Damon wrote:
>> On 6/11/21 5:07 PM, olcott wrote:
>>> On 6/11/2021 3:57 PM, Richard Damon wrote:
>>>>
>>>> And I have NEVER said it didn't. When you quote the RULE, I object
>>>> to it
>>>> as the rule can be wrong for cases like H_Hat, but a wrong rule can get
>>>> some cases right.
>>> So you agree with this:
>>> When-so-ever an input demonstrates an infinitely repeating pattern and
>>> this repeating pattern is caused by an infinite loop or infinite
>>> recursion then the simulating halt decider can stop simulating its input
>>> and report that this input does not halt.
>>>
>>
>> If it si TRUELY an infinitely repeating pattern with no possible break,
>> then the decider can stop the simulation and report not-halitng.
>>
>> Note, if it sees a decider in the loop, then it needs to allow for the
>> action of the decider. This is where you fail for H_Hat.
>>
>
> We can artificially contrive an undecidable problem depending on how we
> frame the problem or we can remove this artificial contrivance.

But the Halting Problme isn't 'artificially contrived', and as such
there is no artifical contrivances that can be removed. It has
legitimate applicability in mathematical theory which needs it exactly
as stated.

As I have said before, you are perfectly free to define you own version
of the halting problem with a different definition as long as you make
it clear that this is what you are doing. The one thing that this will
mean is that you alternate problem won't matter to all those other
proofs that derive themselves from the proof of the halting problem's
impossibility.

>
> It is self-evident that any computation that will never halt unless its
> simulation is aborted is merely a computationally equivalent way to
> define that a computation does not halt.

But ONLY with the right definition. The key difference between that and
the one you use is the right definition say that it must be the instance
of the decider that is making the actual decision that must stop the
simulation, it doesn't count if it is another copy that must.

>
> We know this on the basis that a UTM simulation of a TM description ⟨P⟩
> that does not halt logically entails that the TM P does not halt.

Right. And your interpretation where even if the input as given will
halt when given to a UTM but if the input is modified to have copies of
the decider replaced with a UTM and THAT makes it not halt, it is
correct to call it non-halting is wrong.

The rule is that H(P,I) should return Halting if, and only if UTM(P,I)
is a Halting Computation which by the definition of a UTM is if and only
if P(I) is a Halting Computation which is exactly the defintion.
>
> A simulating halt decider applies this computationally equivalent
> definition of non-halting does correctly decide that both the pseudo-code
>
> procedure compute_g(i):
>   if f(i, i) == 0 then
>     return 0
>   else
>     loop forever    // (Wikipedia:Halting Problem)
>
> and the Linz Ĥ
>
> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
> if M applied to wM halts, and
>
> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
> if M applied to wM does not halt
>
> counter-examples are merely computations that do not halt on their input.
>

Right, and since for your H it has been shown that it will answer
non-Halting for this input and H^ will then Halt that H gave the wrong
answer when feed the description of this machine.

On 6/11/2021 5:59 PM, Richard Damon wrote:
> On 6/11/21 6:17 PM, olcott wrote:
>> On 6/11/2021 4:38 PM, Richard Damon wrote:
>>> On 6/11/21 5:07 PM, olcott wrote:
>>>> On 6/11/2021 3:57 PM, Richard Damon wrote:
>>>>>
>>>>> And I have NEVER said it didn't. When you quote the RULE, I object
>>>>> to it
>>>>> as the rule can be wrong for cases like H_Hat, but a wrong rule can get
>>>>> some cases right.
>>>> So you agree with this:
>>>> When-so-ever an input demonstrates an infinitely repeating pattern and
>>>> this repeating pattern is caused by an infinite loop or infinite
>>>> recursion then the simulating halt decider can stop simulating its input
>>>> and report that this input does not halt.
>>>>
>>>
>>> If it si TRUELY an infinitely repeating pattern with no possible break,
>>> then the decider can stop the simulation and report not-halitng.
>>>
>>> Note, if it sees a decider in the loop, then it needs to allow for the
>>> action of the decider. This is where you fail for H_Hat.
>>>
>>
>> We can artificially contrive an undecidable problem depending on how we
>> frame the problem or we can remove this artificial contrivance.
>
> But the Halting Problme isn't 'artificially contrived', and as such
> there is no artifical contrivances that can be removed. It has
> legitimate applicability in mathematical theory which needs it exactly
> as stated.
>
> As I have said before, you are perfectly free to define you own version
> of the halting problem with a different definition as long as you make
> it clear that this is what you are doing. The one thing that this will
> mean is that you alternate problem won't matter to all those other
> proofs that derive themselves from the proof of the halting problem's
> impossibility.
>
>>
>> It is self-evident that any computation that will never halt unless its
>> simulation is aborted is merely a computationally equivalent way to
>> define that a computation does not halt.
>
> But ONLY with the right definition. The key difference between that and
> the one you use is the right definition say that it must be the instance
> of the decider that is making the actual decision that must stop the
> simulation, it doesn't count if it is another copy that must.
>
>>
>> We know this on the basis that a UTM simulation of a TM description ⟨P⟩
>> that does not halt logically entails that the TM P does not halt.
>
> Right. And your interpretation where even if the input as given will
> halt when given to a UTM but if the input is modified to have copies of
> the decider replaced with a UTM and THAT makes it not halt, it is
> correct to call it non-halting is wrong.
>
> The rule is that H(P,I) should return Halting if, and only if UTM(P,I)
> is a Halting Computation which by the definition of a UTM is if and only
> if P(I) is a Halting Computation which is exactly the defintion.
>>
>> A simulating halt decider applies this computationally equivalent
>> definition of non-halting does correctly decide that both the pseudo-code
>>
>> procedure compute_g(i):
>>   if f(i, i) == 0 then
>>     return 0
>>   else
>>     loop forever    // (Wikipedia:Halting Problem)
>>
>> and the Linz Ĥ
>>
>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
>> if M applied to wM halts, and
>>
>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
>> if M applied to wM does not halt
>>
>> counter-examples are merely computations that do not halt on their input.
>>
>
> Right, and since for your H it has been shown that it will answer
> non-Halting for this input and H^ will then Halt that H gave the wrong
> answer when feed the description of this machine.
>

This is the key part that you have persistently ignored:

There is no case where the simulation of the input to H(P, P) would ever
halt unless this simulation is aborted.

--
Copyright 2021 Pete Olcott

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

On 6/11/21 7:09 PM, olcott wrote:
> On 6/11/2021 5:59 PM, Richard Damon wrote:
>> On 6/11/21 6:17 PM, olcott wrote:
>>> On 6/11/2021 4:38 PM, Richard Damon wrote:
>>>> On 6/11/21 5:07 PM, olcott wrote:
>>>>> On 6/11/2021 3:57 PM, Richard Damon wrote:
>>>>>>
>>>>>> And I have NEVER said it didn't. When you quote the RULE, I object
>>>>>> to it
>>>>>> as the rule can be wrong for cases like H_Hat, but a wrong rule
>>>>>> can get
>>>>>> some cases right.
>>>>> So you agree with this:
>>>>> When-so-ever an input demonstrates an infinitely repeating pattern and
>>>>> this repeating pattern is caused by an infinite loop or infinite
>>>>> recursion then the simulating halt decider can stop simulating its
>>>>> input
>>>>> and report that this input does not halt.
>>>>>
>>>>
>>>> If it si TRUELY an infinitely repeating pattern with no possible break,
>>>> then the decider can stop the simulation and report not-halitng.
>>>>
>>>> Note, if it sees a decider in the loop, then it needs to allow for the
>>>> action of the decider. This is where you fail for H_Hat.
>>>>
>>>
>>> We can artificially contrive an undecidable problem depending on how we
>>> frame the problem or we can remove this artificial contrivance.
>>
>> But the Halting Problme isn't 'artificially contrived', and as such
>> there is no artifical contrivances that can be removed. It has
>> legitimate applicability in mathematical theory which needs it exactly
>> as stated.
>>
>> As I have said before, you are perfectly free to define you own version
>> of the halting problem with a different definition as long as you make
>> it clear that this is what you are doing. The one thing that this will
>> mean is that you alternate problem won't matter to all those other
>> proofs that derive themselves from the proof of the halting problem's
>> impossibility.
>>
>>>
>>> It is self-evident that any computation that will never halt unless its
>>> simulation is aborted is merely a computationally equivalent way to
>>> define that a computation does not halt.
>>
>> But ONLY with the right definition. The key difference between that and
>> the one you use is the right definition say that it must be the instance
>> of the decider that is making the actual decision that must stop the
>> simulation, it doesn't count if it is another copy that must.
>>
>>>
>>> We know this on the basis that a UTM simulation of a TM description ⟨P⟩
>>> that does not halt logically entails that the TM P does not halt.
>>
>> Right. And your interpretation where even if the input as given will
>> halt when given to a UTM but if the input is modified to have copies of
>> the decider replaced with a UTM and THAT makes it not halt, it is
>> correct to call it non-halting is wrong.
>>
>> The rule is that H(P,I) should return Halting if, and only if UTM(P,I)
>> is a Halting Computation which by the definition of a UTM is if and only
>> if P(I) is a Halting Computation which is exactly the defintion.
>>>
>>> A simulating halt decider applies this computationally equivalent
>>> definition of non-halting does correctly decide that both the
>>> pseudo-code
>>>
>>> procedure compute_g(i):
>>>    if f(i, i) == 0 then
>>>      return 0
>>>    else
>>>      loop forever    // (Wikipedia:Halting Problem)
>>>
>>> and the Linz Ĥ
>>>
>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
>>> if M applied to wM halts, and
>>>
>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
>>> if M applied to wM does not halt
>>>
>>> counter-examples are merely computations that do not halt on their
>>> input.
>>>
>>
>> Right, and since for your H it has been shown that it will answer
>> non-Halting for this input and H^ will then Halt that H gave the wrong
>> answer when feed the description of this machine.
>>
>
> This is the key part that you have persistently ignored:
>
> There is no case where the simulation of the input to H(P, P) would ever
> halt unless this simulation is aborted.
>

But that doesn't matter. Even you just above agreed that the right
answer that H needs to produce is will UTM(P, P) halt or not, and for
your H the H^ based on it DOES, so the right answer is Halting, even
though H says non-Halting.

The key is H halted the simulation, but it turns out that in that
particular case it really didn't need to because H^ will halt because
the H inside it will stop the potential infinite recursion and let H^
come to a Halt. The fact that H made the mistake of deciding that H^ was
non-Halting allows H^ to BE Halting.