The standard pseudo-code halting problem template "proves" 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 to this input.
It aborts the simulation of its input on the basis that its input
specifies what is essentially infinite recursion to any simulating halt
decider.

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

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

The above is fully operational in the x86utm operating system, it is
based on an x86 emulator that does a debug step trace of its input. It
examines the stored execution trace after it simulates each instruction
of this input.

The simulation of P by H must be aborted or P has behavior similar to
infinite recursion. When any one of an infinitely recursive chain of
invocations is aborted the entire chain stops.

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.

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 5:32 PM, dklei...@gmail.com wrote:
> On Friday, June 11, 2021 at 10:29:14 AM UTC-7, olcott wrote:
>
>> There is no case where the simulation of the input to H(P, P) would ever
>> halt unless this simulation is aborted.
>
> H is defined as a decider thus it halts by itself and therefore any
> simulation of H will halt.
>

Not true, just because you CALL something a decider doesn't mean that it
will succeed at being one. His H has many pattern that when given will
cause the decider to go into infinite execution and it will never decide.

On 6/11/2021 4:32 PM, dklei...@gmail.com wrote:
> On Friday, June 11, 2021 at 10:29:14 AM UTC-7, olcott wrote:
>
>> There is no case where the simulation of the input to H(P, P) would ever
>> halt unless this simulation is aborted.
>
> H is defined as a decider thus it halts by itself and therefore any
> simulation of H will halt.
>

If H is a simulating halt decider then the only possible way for it to
remain a decider is that is must abort the simulations of inputs that
would never otherwise halt.

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

This means that H must always abort this computation:
H((u32)P, (u32)P);

This short little sentence is the whole key to refuting the halting
problem proofs:

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 a computation that does not halt.

--
Copyright 2021 Pete Olcott

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

On 6/11/2021 4:40 PM, Richard Damon wrote:
> On 6/11/21 5:32 PM, dklei...@gmail.com wrote:
>> On Friday, June 11, 2021 at 10:29:14 AM UTC-7, olcott wrote:
>>
>>> There is no case where the simulation of the input to H(P, P) would ever
>>> halt unless this simulation is aborted.
>>
>> H is defined as a decider thus it halts by itself and therefore any
>> simulation of H will halt.
>>
>
> Not true, just because you CALL something a decider doesn't mean that it
> will succeed at being one.

It either succeeds at being one or you lied about it being a decider.

> His H has many pattern that when given will
> cause the decider to go into infinite execution and it will never decide.
>

--
Copyright 2021 Pete Olcott

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

On 6/11/21 6:18 PM, olcott wrote:
> On 6/11/2021 4:40 PM, Richard Damon wrote:
>> On 6/11/21 5:32 PM, dklei...@gmail.com wrote:
>>> On Friday, June 11, 2021 at 10:29:14 AM UTC-7, olcott wrote:
>>>
>>>> There is no case where the simulation of the input to H(P, P) would
>>>> ever
>>>> halt unless this simulation is aborted.
>>>
>>> H is defined as a decider thus it halts by itself and therefore any
>>> simulation of H will halt.
>>>
>>
>> Not true, just because you CALL something a decider doesn't mean that it
>> will succeed at being one.
>
> It either succeeds at being one or you lied about it being a decider.
>

Yes, but just because you call it one doesn't mean you have positively
proved it. Since you call H at times a partial decider, that can mean
that for some inputs you don't even make the claim that it does halt.

>>  His H has many pattern that when given will
>> cause the decider to go into infinite execution and it will never decide.
>>
>
>

On 6/11/2021 5:25 PM, Richard Damon wrote:
> On 6/11/21 6:18 PM, olcott wrote:
>> On 6/11/2021 4:40 PM, Richard Damon wrote:
>>> On 6/11/21 5:32 PM, dklei...@gmail.com wrote:
>>>> On Friday, June 11, 2021 at 10:29:14 AM UTC-7, olcott wrote:
>>>>
>>>>> There is no case where the simulation of the input to H(P, P) would
>>>>> ever
>>>>> halt unless this simulation is aborted.
>>>>
>>>> H is defined as a decider thus it halts by itself and therefore any
>>>> simulation of H will halt.
>>>>
>>>
>>> Not true, just because you CALL something a decider doesn't mean that it
>>> will succeed at being one.
>>
>> It either succeeds at being one or you lied about it being a decider.
>>
>
> Yes, but just because you call it one doesn't mean you have positively
> proved it. Since you call H at times a partial decider, that can mean
> that for some inputs you don't even make the claim that it does halt.

I am only concerned with the inputs used as the basis for the halting
problem proofs.

>
>>>  His H has many pattern that when given will
>>> cause the decider to go into infinite execution and it will never decide.
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

On 6/11/21 6:03 PM, olcott wrote:
> On 6/11/2021 4:32 PM, dklei...@gmail.com wrote:
>> On Friday, June 11, 2021 at 10:29:14 AM UTC-7, olcott wrote:
>>
>>> There is no case where the simulation of the input to H(P, P) would ever
>>> halt unless this simulation is aborted.
>>
>> H is defined as a decider thus it halts by itself and therefore any
>> simulation of H will halt.
>>
>
> If H is a simulating halt decider then the only possible way for it to
> remain a decider is that is must abort the simulations of inputs that
> would never otherwise halt.

But, that need is a different need than that for the decision, as we are
look at different layers of the recursion. If H^ turns out to be finite
in execution then H didn't really NEED to abort the simulation, but it
did anyway. You run into the problem that if you don't abort you can get
stuck in the infinite recursion but once you add that halt, you no
longer have the infinite recursion but you need to figure if H^ will
halt or not, but you don't have enough information to make the right
decision, and in fact no answer you can return will be right.

This just means you can't be an always correct halting decider, but
nothing said you had to be able to be one.

Tring to DESIGN the H means you have to solve a paradox that is similar
to "This statement is false". The key is that this is done before you
need to test things, and at test time there is no paradox, so the
halting question itself doesn't have the paradox, for a given H, H^ will
be either halting or non-halting, so there IS a right answer for the
question of does H^ Halt. The problem is that it is impossible for H to
give it, since H^ is built based on H so can it can act in the contrary
manner.

>
> void P(u32 x)
> {
>   u32 Input_Halts = H(x, x);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> This means that H must always abort this computation:
>   H((u32)P, (u32)P);
>
> This short little sentence is the whole key to refuting the halting
> problem proofs:
>
> 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 a computation that does not halt.
>

But if you replace H with UTM(P, P) we see that this computation does
halt, so that top H did NOT need to abort the simulation, so the clause,
when properly interpreted doesn't apply.