01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }

Any computation that only stops running because
some step of this computation has been aborted
DOES NOT HALT!

The directly executed D(D) only stops running
because the recursive invocation that it specifies
has been aborted.

On 1/20/2024 7:50 PM, Richard Damon wrote:
> HH STILL Can't do a correct simulation of that input, as a
> correct simulation of that input takes an unbounded number
> of steps...

HH correctly detects that in N steps of correct simulation
which means this:

DD correctly simulated by HH cannot possibly reach its simulated
final state in 1 to ∞ steps of correct simulation.

HH correctly detects this after N steps of correct simulation.

Thus meeting the halt criteria that it is ALWAYS correct to
abort any simulation and report non-halting for any input that
would not otherwise terminate.

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

On 1/24/24 19:08, olcott wrote:
> [nonsense]

The directly executed D(D) reaches a final state and exits normally.

On 1/24/2024 12:15 PM, immibis wrote:
> On 1/24/24 19:08, olcott wrote:
>> [nonsense]
>
> The directly executed D(D) reaches a final state and exits normally.

The directly executed D(D) reaches a final state and exits normally.
BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
Thus meeting the correct non-halting criteria if any step of
a computation must be aborted to prevent its infinite execution
then this computation DOES NOT HALT (even if it looks like it does).

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

On 1/24/24 19:18, olcott wrote:
> On 1/24/2024 12:15 PM, immibis wrote:
>> On 1/24/24 19:08, olcott wrote:
>>> [nonsense]
>>
>> The directly executed D(D) reaches a final state and exits normally.
>
> The directly executed D(D) reaches a final state and exits normally.
> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
> Thus meeting the correct non-halting criteria if any step of
> a computation must be aborted to prevent its infinite execution
> then this computation DOES NOT HALT (even if it looks like it does).
>

A program which reaches a final state and exits normally halts.

A program which is aborted does not reach a final state and exit normally.

On 1/24/2024 12:53 PM, immibis wrote:
> On 1/24/24 19:18, olcott wrote:
>> On 1/24/2024 12:15 PM, immibis wrote:
>>> On 1/24/24 19:08, olcott wrote:
>>>> [nonsense]
>>>
>>> The directly executed D(D) reaches a final state and exits normally.
>>
>> The directly executed D(D) reaches a final state and exits normally.
>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>> Thus meeting the correct non-halting criteria if any step of
>> a computation must be aborted to prevent its infinite execution
>> then this computation DOES NOT HALT (even if it looks like it does).
>>
>
> A program which reaches a final state and exits normally halts.
>
> A program which is aborted does not reach a final state and exit normally.

Infinite recursion that has its second recursive call
aborted superficially seems to halt.

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

On 1/24/24 19:56, olcott wrote:
> On 1/24/2024 12:53 PM, immibis wrote:
>> On 1/24/24 19:18, olcott wrote:
>>> On 1/24/2024 12:15 PM, immibis wrote:
>>>> On 1/24/24 19:08, olcott wrote:
>>>>> [nonsense]
>>>>
>>>> The directly executed D(D) reaches a final state and exits normally.
>>>
>>> The directly executed D(D) reaches a final state and exits normally.
>>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>>> Thus meeting the correct non-halting criteria if any step of
>>> a computation must be aborted to prevent its infinite execution
>>> then this computation DOES NOT HALT (even if it looks like it does).
>>>
>>
>> A program which reaches a final state and exits normally halts.
>>
>> A program which is aborted does not reach a final state and exit
>> normally.
>
> Infinite recursion that has its second recursive call
> aborted superficially seems to halt.
>
An aborted simulation returns normal control to the simulator.

On 1/24/2024 12:58 PM, immibis wrote:
> On 1/24/24 19:56, olcott wrote:
>> On 1/24/2024 12:53 PM, immibis wrote:
>>> On 1/24/24 19:18, olcott wrote:
>>>> On 1/24/2024 12:15 PM, immibis wrote:
>>>>> On 1/24/24 19:08, olcott wrote:
>>>>>> [nonsense]
>>>>>
>>>>> The directly executed D(D) reaches a final state and exits normally.
>>>>
>>>> The directly executed D(D) reaches a final state and exits normally.
>>>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>>>> Thus meeting the correct non-halting criteria if any step of
>>>> a computation must be aborted to prevent its infinite execution
>>>> then this computation DOES NOT HALT (even if it looks like it does).
>>>>
>>>
>>> A program which reaches a final state and exits normally halts.
>>>
>>> A program which is aborted does not reach a final state and exit
>>> normally.
>>
>> Infinite recursion that has its second recursive call
>> aborted superficially seems to halt.
>>
> An aborted simulation returns normal control to the simulator.

01 int Infinite_Recursion(u32 N)
02 {
03 Infinite_Recursion(N);
04 return 1;
05 }

When ONLY the recursive invocation is aborted
(H simply skips line 03) then Infinite_Recursion()
returns 1 to its caller.

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

On 1/24/24 1:18 PM, olcott wrote:
> On 1/24/2024 12:15 PM, immibis wrote:
>> On 1/24/24 19:08, olcott wrote:
>>> [nonsense]
>>
>> The directly executed D(D) reaches a final state and exits normally.
>
> The directly executed D(D) reaches a final state and exits normally.
> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
> Thus meeting the correct non-halting criteria if any step of
> a computation must be aborted to prevent its infinite execution
> then this computation DOES NOT HALT (even if it looks like it does).
>

I'E, you think if I kill John, then his twin brother James will fall
over dead.

The fact athat ONE copy of D had its simulation abborted does not affect
anothe rcopy of that same computation.

By your ending statement, yo are just announcing that you are not
working on the Hatling problem but POOP, as the Halting Criteria is NOT
about "correct simulation" needing to be aborted, but about the behavior
of the actual machine directly run and if it reaches a final state.

Maybe you have great POOP, but you don't know what it means to Halt.

So, I guess you life if just overflowing with that unending POOP.

On 1/24/24 1:56 PM, olcott wrote:
> On 1/24/2024 12:53 PM, immibis wrote:
>> On 1/24/24 19:18, olcott wrote:
>>> On 1/24/2024 12:15 PM, immibis wrote:
>>>> On 1/24/24 19:08, olcott wrote:
>>>>> [nonsense]
>>>>
>>>> The directly executed D(D) reaches a final state and exits normally.
>>>
>>> The directly executed D(D) reaches a final state and exits normally.
>>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>>> Thus meeting the correct non-halting criteria if any step of
>>> a computation must be aborted to prevent its infinite execution
>>> then this computation DOES NOT HALT (even if it looks like it does).
>>>
>>
>> A program which reaches a final state and exits normally halts.
>>
>> A program which is aborted does not reach a final state and exit
>> normally.
>
> Infinite recursion that has its second recursive call
> aborted superficially seems to halt.
>

If the outer copy halts because of that, it DOES.

DEFINITION.

You are just full of your POOP.

On 1/24/24 20:10, olcott wrote:
> On 1/24/2024 12:58 PM, immibis wrote:
>> On 1/24/24 19:56, olcott wrote:
>>> On 1/24/2024 12:53 PM, immibis wrote:
>>>> On 1/24/24 19:18, olcott wrote:
>>>>> On 1/24/2024 12:15 PM, immibis wrote:
>>>>>> On 1/24/24 19:08, olcott wrote:
>>>>>>> [nonsense]
>>>>>>
>>>>>> The directly executed D(D) reaches a final state and exits normally.
>>>>>
>>>>> The directly executed D(D) reaches a final state and exits normally.
>>>>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>>>>> Thus meeting the correct non-halting criteria if any step of
>>>>> a computation must be aborted to prevent its infinite execution
>>>>> then this computation DOES NOT HALT (even if it looks like it does).
>>>>>
>>>>
>>>> A program which reaches a final state and exits normally halts.
>>>>
>>>> A program which is aborted does not reach a final state and exit
>>>> normally.
>>>
>>> Infinite recursion that has its second recursive call
>>> aborted superficially seems to halt.
>>>
>> An aborted simulation returns normal control to the simulator.
>
> 01 int Infinite_Recursion(u32 N)
> 02 {
> 03  Infinite_Recursion(N);
> 04  return 1;
> 05 }
>
> When ONLY the recursive invocation is aborted
> (H simply skips line 03) then Infinite_Recursion()
> returns 1 to its caller.
>
The CPU which directly executes Infinite_Recursion cannot skip line 3.

H is not involved. Why do you fucking talk about H? There is no H. There
is only Infinite_Recursion.

On 1/25/2024 7:16 AM, immibis wrote:
> On 1/24/24 20:10, olcott wrote:
>> On 1/24/2024 12:58 PM, immibis wrote:
>>> On 1/24/24 19:56, olcott wrote:
>>>> On 1/24/2024 12:53 PM, immibis wrote:
>>>>> On 1/24/24 19:18, olcott wrote:
>>>>>> On 1/24/2024 12:15 PM, immibis wrote:
>>>>>>> On 1/24/24 19:08, olcott wrote:
>>>>>>>> [nonsense]
>>>>>>>
>>>>>>> The directly executed D(D) reaches a final state and exits normally.
>>>>>>
>>>>>> The directly executed D(D) reaches a final state and exits normally.
>>>>>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>>>>>> Thus meeting the correct non-halting criteria if any step of
>>>>>> a computation must be aborted to prevent its infinite execution
>>>>>> then this computation DOES NOT HALT (even if it looks like it does).
>>>>>>
>>>>>
>>>>> A program which reaches a final state and exits normally halts.
>>>>>
>>>>> A program which is aborted does not reach a final state and exit
>>>>> normally.
>>>>
>>>> Infinite recursion that has its second recursive call
>>>> aborted superficially seems to halt.
>>>>
>>> An aborted simulation returns normal control to the simulator.
>>
>> 01 int Infinite_Recursion(u32 N)
>> 02 {
>> 03  Infinite_Recursion(N);
>> 04  return 1;
>> 05 }
>>
>> When ONLY the recursive invocation is aborted
>> (H simply skips line 03) then Infinite_Recursion()
>> returns 1 to its caller.
>>
> The CPU which directly executes Infinite_Recursion cannot skip line 3.
>

It is a virtual CPU that the simulator can do whatever
it wants to.

> H is not involved.

H is the primary termination analyzer that analyzes most of
the same inputs.

> Why do you fucking talk about H? There is no H. There
> is only Infinite_Recursion.

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

On 1/25/24 16:04, olcott wrote:
> On 1/25/2024 7:16 AM, immibis wrote:
>> On 1/24/24 20:10, olcott wrote:
>>> On 1/24/2024 12:58 PM, immibis wrote:
>>>> On 1/24/24 19:56, olcott wrote:
>>>>> On 1/24/2024 12:53 PM, immibis wrote:
>>>>>> On 1/24/24 19:18, olcott wrote:
>>>>>>> On 1/24/2024 12:15 PM, immibis wrote:
>>>>>>>> On 1/24/24 19:08, olcott wrote:
>>>>>>>>> [nonsense]
>>>>>>>>
>>>>>>>> The directly executed D(D) reaches a final state and exits
>>>>>>>> normally.
>>>>>>>
>>>>>>> The directly executed D(D) reaches a final state and exits normally.
>>>>>>> BECAUSE ANOTHER ASPECT OF THE SAME COMPUTATION HAS BEEN ABORTED,
>>>>>>> Thus meeting the correct non-halting criteria if any step of
>>>>>>> a computation must be aborted to prevent its infinite execution
>>>>>>> then this computation DOES NOT HALT (even if it looks like it does).
>>>>>>>
>>>>>>
>>>>>> A program which reaches a final state and exits normally halts.
>>>>>>
>>>>>> A program which is aborted does not reach a final state and exit
>>>>>> normally.
>>>>>
>>>>> Infinite recursion that has its second recursive call
>>>>> aborted superficially seems to halt.
>>>>>
>>>> An aborted simulation returns normal control to the simulator.
>>>
>>> 01 int Infinite_Recursion(u32 N)
>>> 02 {
>>> 03  Infinite_Recursion(N);
>>> 04  return 1;
>>> 05 }
>>>
>>> When ONLY the recursive invocation is aborted
>>> (H simply skips line 03) then Infinite_Recursion()
>>> returns 1 to its caller.
>>>
>> The CPU which directly executes Infinite_Recursion cannot skip line 3.
>>
>
> It is a virtual CPU that the simulator can do whatever
> it wants to.

No, it is a real CPU. That is what direct execution means. Direct
execution means execution on a real CPU.

>
>> H is not involved.
>
> H is the primary termination analyzer that analyzes most of
> the same inputs.

H is not my CPU.

>
>> Why do you fucking talk about H? There is no H. There is only
>> Infinite_Recursion.
>