When one understands that H is always correct to abort any
simulation that cannot possibly stop running unless aborted

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 }
08
09 void main()
10 {
11 H(D,D);
12 }

as every H specified by the above template must do then each
and every element of this infinite set is correct to abort
its simulation of D and reject its input D as non-halting.

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

Op 31.jan.2024 om 04:56 schreef olcott:
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 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 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> as every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation of D and reject its input D as non-halting.
>

It is easy to see that noone can understand it, because it is not true.
Han aborts is simulation, so it is not necessary to abort Dan, which is
based on Han, because it aborts it own simulation already. Then it
returns a non-halting status and Dan continues with line 04.
Han(Dan,Dan) should decide for its input Dan, which aborts its
simulation, not for its non-input Dss which has an infinite recursion.
If H is of the Han type (aborts and reports non-halting), then it is
simply incorrect to abort a D (of the Dan type) that aborts it own
simulation already.

On 1/30/24 10:56 PM, olcott wrote:
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 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 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> as every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation of D and reject its input D as non-halting.
>

No, H is only correct to abort and report non-halting, if that exact
same program it was looking at (using the exact same H as that H was)
will not halt when run.

If the code of that H is coded to abort and return non-halting, then
that input will be Halting, and thus that H was wrong.

This goes back to the comments about the "Illusion of Truth", as, H,
isn't looking at the input that it was ACTUALLY given, but the
programmer of it was reasoning (not the program, as programs don't
"reason" only obey their programmong) if he wrote a different program,
that didn't abort, then the input IT was given (neglecting that this
input would be DIFFERENT, as it is based on a different H) must have its
simulation aborted. But since that is a different input, you can't
migrate that answer to the input it was actually given.

Your problem is you just don't understand the fundamental terms you are
using. Halting is about Specific input that decribe specific programs.
"Templates" themselves are NOT valid inputs, only ways to make valid
inputs.h
THe above is NOT such a valid input, but needs the definition of H
included. Once you define that this is using a specific H, you aren't
allowed to change that for this input, which your logic does.

Thus, you are just proving that all you are talking about is POOP and
not halting.

On 1/31/24 04:56, olcott wrote:
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 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 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> as every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation of D and reject its input D as non-halting.
>

When one understands the halting problem is about whether an execution
sequence is finite or infinite, NOT whether any H is always correct to
abort any simulation, one realizes your post is irrelevant nonsense.

On 1/31/24 04:56, olcott wrote:
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 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 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> as every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation of D and reject its input D as non-halting.
>

When one realizes that a halting decider has to interpret its input
specification in the exact same way that a UTM would, and not in any
other way, and that the specification is not subjective, it is obvious
that D specifies halting behaviour if H returns 0.

On 1/31/2024 3:47 AM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 04:56 schreef olcott:
>> When one understands that H is always correct to abort any
>> simulation that cannot possibly stop running unless aborted
>>
>> 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 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> as every H specified by the above template must do then each
>> and every element of this infinite set is correct to abort
>> its simulation of D and reject its input D as non-halting.
>>
>
> It is easy to see that noone can understand it, because it is not true.

*Here is better wording*

Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.

When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted:

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 }
08
09 void main()
10 {
11 H(D,D);
12 }

Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

On 1/31/2024 6:31 AM, immibis wrote:
> On 1/31/24 04:56, olcott wrote:
>> When one understands that H is always correct to abort any
>> simulation that cannot possibly stop running unless aborted
>>
>> 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 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> as every H specified by the above template must do then each
>> and every element of this infinite set is correct to abort
>> its simulation of D and reject its input D as non-halting.
>>
>
> When one understands the halting problem is about whether an execution
> sequence is finite or infinite, NOT whether any H is always correct to
> abort any simulation, one realizes your post is irrelevant nonsense.

Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.

*When one understands that simulating termination analyzer H*
*is always correct to abort any simulation that cannot possibly*
*stop running unless aborted*

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 }
08
09 void main()
10 {
11 H(D,D);
12 }

Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

On 1/31/24 16:41, olcott wrote:
> On 1/31/2024 6:31 AM, immibis wrote:
>> On 1/31/24 04:56, olcott wrote:
>>> When one understands that H is always correct to abort any
>>> simulation that cannot possibly stop running unless aborted
>>>
>>> 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 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> as every H specified by the above template must do then each
>>> and every element of this infinite set is correct to abort
>>> its simulation of D and reject its input D as non-halting.
>>>
>>
>> When one understands the halting problem is about whether an execution
>> sequence is finite or infinite, NOT whether any H is always correct to
>> abort any simulation, one realizes your post is irrelevant nonsense.
>
> Below I reference an infinite set of simulating termination
> analyzers

When one understands the halting problem is about whether an execution
sequence is finite or infinite, NOT whether any H is always correct to
abort any simulation, one realizes your post is irrelevant nonsense.

On 1/30/24 10:56 PM, olcott wrote:
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 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 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> as every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation of D and reject its input D as non-halting.
>

And since the input to a halt decider is a actual program that
implements a computation, every D input, include the H it was defined
with as part of it, and thus, if we need to hypothosize some alternate
H, D doesn't change, but continues to call the original H, since that is
its DEFINITION.

Any H that aborts it simulation, must to meet your criteria show that a
correct simulation (by H or any other simulator, since all correct
simulation of a given input are BY DEFINITION the same).

This simulation will then be:

D(D) is entered

D(D) calls H(D,D)

(your H aborts its simulation here, but a correct simulation continues).

The correct simulation will then start simulating the code of H, while
it simulate the beginning of the computation D(D).

At some point, this simulated H will reach the point above where H
aborts its simulaton, and the correct simulation of this H will also do
that. Remember, the H used by D CAN'T change, even if we hypothesize
some different H to do the analysis of what H needed to have done)

The simulation will then continue seeing this simulated H returning 0 to
D and stored in Halt_Status.

The simulation will then jump to line 06 and return that status and Halt.

If you want to claim that H can't simulate its self, if can also replace
that call to H with the results that we know the call to H will do, and
thus the correct simulation directly jumps from D(D) calling H(D,D) to
H(D,D) returning 0 and that being stored in Halt_Status.

Since this CORRECT simulation, either way, reaches the end state without
THIS H aborting its simulation (which is the only one that matters, as
it is the only one doing THIS simulation) it can not be correct to say
that the simulation needed be aborted. as it DOES halt.

To argue about a D(D) built from a diffferent H is just a Strawman, as
this D(D) is only built from the H that gives the answer, and thus the H
that aborted.

You are thus caught in your LIES.

On 1/31/24 10:41 AM, olcott wrote:
> On 1/31/2024 6:31 AM, immibis wrote:
>> On 1/31/24 04:56, olcott wrote:
>>> When one understands that H is always correct to abort any
>>> simulation that cannot possibly stop running unless aborted
>>>
>>> 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 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> as every H specified by the above template must do then each
>>> and every element of this infinite set is correct to abort
>>> its simulation of D and reject its input D as non-halting.
>>>
>>
>> When one understands the halting problem is about whether an execution
>> sequence is finite or infinite, NOT whether any H is always correct to
>> abort any simulation, one realizes your post is irrelevant nonsense.
>
> Below I reference an infinite set of simulating termination
> analyzers that each correctly aborts its simulation of D
> and correctly rejects D as non-halting.

And thus are talking about POOP.

>
> *When one understands that simulating termination analyzer H*
> *is always correct to abort any simulation that cannot possibly*
> *stop running unless aborted*

Except that is just your ignorant pathological lie. (explained fuller in
another message)

>
> 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 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> Then every simulating termination analyzer H specified by
> the above template correctly aborts its simulation of D
> and correctly rejects D as non-halting.
>

Except it wasn't correct in aborting as the input will halt when
correctly simulated (as long as you remember that D(x) cals the H(x,x)
that claims to answer it, and thus does abort.

> Pages 661 to 696 of Halt7.c specify the H that does this
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>

So you have two parts to your set.

Part 1 are H(D,D) that do not abort, and do not return an answer, and
thus are not deciders.

Part 2 are H(D,D) that do abort, but the correct simuation of this input
uses that same H(D,D) which returns non-halting and that D(D) Halts and
thus so deos its correct simulaiton, BY DEFINITION.

Your arguement pairs H's in Part 2 with inputs from Part 1, which then
is just a lie that you case is done per the requirements of the proof.

So, you are just shown to be an ignorant pathological liar.