XPost: comp.theory, sci.logic

A pair of C functions are defined such that D has the halting problem
proofs pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on (b) Cannot possibly terminate normally
then it is understood that D is correctly determined to be non-halting.

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship
between D and H changes the behavior of D relative to H.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating (unless aborted)*
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*Termination Analyzer H is Not Fooled by Pathological Input D* https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/23/23 12:46 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proofs pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on (b) Cannot possibly terminate normally
then it is understood that D is correctly determined to be non-halting.

BNo, you H doesn't "Correctly iImulate" this input, so "D correctly
Simulated by H" is a non-existant event, and thus, doesn't actually
assert anything. This shows you are just a hypocrite, as you claim that
you can only say something is true if it neccessary follows from the
true premises, but then insist on useing FALSE premises.

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship between D and H changes the behavior of D relative to H.

No, it CAN"T by the definition of "Correctly Simulated"

That like saying Trump must have won the last el4ction, because, reasons.'

You trace show H simulating D to the point that D calls, H, and then H
makes the ERRONEOUS assupmption that a call to H will not return, even
though H establishs (by its own action) that such a call DOES return a 0
in finite time;

Thus, H is just wrong and you are proved to be an ignorant liar.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating (unless aborted)*
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

How is this correct, since an actual correct simulation of this input,
shows that it WILL reach the final state.

The simulation that H does is of a DIFFERENT machine then actually given
to it, because it, in effecrt, closes its eyes and say "I won't look at
H, so I can say it does anything I want to say, even if it is wrong"

*Termination Analyzer H is Not Fooled by Pathological Input D* https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

Proof that you are just a Hypocritical ignorant pathological lying idiot.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non- halting.

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship
between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.



*Termination Analyzer H is Not Fooled by Pathological Input D* https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D



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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

You keep on making the same mistakes,

On 8/25/23 2:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non- halting.

So, you are STIPULATING, that since D(x) calls H(x,x), that this means
askin H about the behavior of the program x given the input x, which
means that D(D) callihg H(D,D) means it is asking H about the behavior
of the program D(D)

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship between D and H changes the behavior of D relative to H.

Nope, that statement just PROVES that you don't understand the meaning
of the words you are using, and are just a ignorant pathological lying
idiot.

For any program H that might determine whether programs halt, a "pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

So? what is wrong with the fact that no H can exist that handles this case?

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Right and a "X decider problem" means the decider must answer based on
the definition of problem X, and a "Halt Decider" must answer based on
whether to program described by its input will halt.

Can D correctly simulated by H terminate normally?

Improper question. Have you stopped lying? (that one actually has an
answer, NO).

Since H doen't actually correctly simulate its input, the question is
based on a false premise.

The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

And your program shows that D(D) DOES HALT, and thus H's answer is WRONG>

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)

LIE.

You H does no such thing, you don't seem to understand that programs do
what they are actually programmed to do.

You are just proving you don't understand the meaning of words like
"Program", "Correct" or even "Logic"

Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Right, your H is defined to ALWAYS abort its simulation of this input,
the, your statement of "keeps repeating" is just a LIE. You condition is irrelevent.

*Simulation invariant*

A meanilngless term (par for you) since in the problem we have a SINGLE
H, with a specified input, so there is nothing to "Vary", so we can't
have an "invariant".

At best, you mean, if we look over all possible H's that meet your
general definition, we can prove the following for all of them.

D correctly simulated by H cannot possibly reach past its own line 06.

Which is a correct conclusion, it is IMPOSSIBLE for any H to be able to simulate the program built by the template to that final state.

THe problem is that this just proves that NO H can, by your logic, can
show that its input is Halting. It says NOTHING about not it being
non-halting.

Remember, every H in this set is a different problem, and creates a
different input, so the results obtained about one input says nothing
about a different one.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

Nope. UNSOUND LOGIC. Since any H that aborts its simulation doesn't do a "Correct SImulation", you don't have anything to make your deduction on.

You are just proving your stupidity.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

But ONLY if H DOES correctly simulate its input, at which point it never aborts, and thus, as you proved above, it never answers.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

Nope, a correcrt simulaiton of D by ANYTHING (includeing H) must include
the ACTUAL behavior of H, not the behavior of some other program.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

Nope, just shows you don't understand what correct logic requires.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

Right, and it needs to give the correct answer to be correct.

You are just proving that you are an ignorant pathological lying idiot.

*Termination Analyzer H is Not Fooled by Pathological Input D* https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

Just shows your stupidity to the world.


Note, the fact that you keep on making the same DISPROVEN claims, shows
you are just a brain damaged insane moron.

You seem to be incapable of learning.

This seems to prove that you are just a pathological liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non- halting.

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a "pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.


*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

So, you STILL don't understand that a program does what it is actually programmed to do, and nothing else,

And to talk about what a program "would" have done if, as something
different than what it actually does, is just a LIE.

H can't make a correct decision based on behavior of a DIFFERENT program
given a DIFFERENT input and say this answer applies here.

The question that H MUST answer, is "Does the machine represented by its
input Halt?"

Since H(D,D) returns 0, it is shown that D(D) Halts, and thus the
CORRECT answer for a Halt Decider is Halting, so H is just WRONG.

You are just proving yourself to be an ignorant pathological lying idiot
that just doesn't know what he is talking about.

YOU FAIL.

Just repeating your same claim over and over just proves you are INSANE,
as well as Stupid, and incapable of learning, and can't actually do any
real logic.


On 8/27/23 11:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non-
halting.

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship
between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly
terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/27/2023 10:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non-
halting.

We can know that D correctly simulated by H must have different behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship
between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly
terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

(5) Of the infinite set of every possible H where D is correctly
simulated by H there are only a THREE categories of possible
behaviors for H: (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:
(a) Return 0 indicating that D correctly simulated by H cannot
possibly terminate normally.

(b) Return 1 indicating that D correctly simulated by H will
terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which
of these options are incorrect on the basis of the source-code of D.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/27/23 1:13 PM, olcott wrote:

On 8/27/2023 10:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non- >>> halting.

We can know that D correctly simulated by H must have different behavior >>> than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship
between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly
terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

(5) Of the infinite set of every possible H where D is correctly
simulated by H there are only a THREE categories of possible
behaviors for H:  (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:
   (a) Return 0 indicating that D correctly simulated by H cannot
       possibly terminate normally.

   (b) Return 1 indicating that D correctly simulated by H will
       terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which
of these options are incorrect on the basis of the source-code of D.

And ALL of your H's are shown to be incorrect for the input they were given.

Remember, each was given a DIFFERENT input, as you are giving it the D
built on IT, so each is a DIFFERENET input

So, you just proved what you claimed to refute, because you are actually
THAT STUPID.

Problem Statement: H needs to return correct answer that corresponds to
the actual behavior of the machine represented by its input when it is run.

Class 1a:
H aborts its simulation after some time and returns 0 (saying non-halting)
By the definition of D, that D, when actually run, will get that 0
returned and then HALT.

So H was wrong.

Class 1b:
H aborts its simulation after some time and returns 1 (Saying Halting).
By the definition of D, that D, when actually run, will get that 1
returned to it, and then go into an infinite loop, and never halt.

So H was wrong.

Class 2:

H never aborts is simulation of D, and thus gets stuck in an infinite
recursion and thus never gives an answer.

So H is wrong.


Thus, you have shown that for EVERY POSSIBLE H, built by you system,
NONE of them gave the correct answer for its input.

You are just proving that you are lying about working on the problem
that you claim you are, likely because you are just too stupid to
understand it.


You seem to think that one program can be all of the above, and its
input is also all of the above.

That shows you don't understand what a "program" is.

YOU FAIL.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/27/23 3:31 PM, olcott wrote:

On 8/27/2023 12:13 PM, olcott wrote:

On 8/27/2023 10:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H. >>>> When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be
non-
halting.

We can know that D correctly simulated by H must have different
behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship >>>> between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what >>>> H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function >>>> to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06. >>>>
H correctly determines that D correctly simulated by H cannot possibly >>>> terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

(5) Of the infinite set of every possible H where D is correctly
simulated by H there are only a THREE categories of possible
behaviors for H:  (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:
    (a) Return 0 indicating that D correctly simulated by H cannot
        possibly terminate normally.

    (b) Return 1 indicating that D correctly simulated by H will
        terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which
of these options are incorrect on the basis of the source-code of D.

When a termination analyzer is required to provide the halt status or an input that deliberately contradicts whatever Boolean value that this termination analyzer returns the halting problem merely mirrors the Liar Paradox.

Nope, and shows your ignorance.

To be applicable to the problem, your "Termination Analyzer" must be an
actual program, and thus it must give an actual answer.

IF H is this "Termination Analyzer" then it also must be an actual
program an d thus gives an actual specific answer for any specific input.

The input D, built on the program H, WILL be an actual program (since H
is) and thus is in the domain of the Analyzer, since the problem
statement says for ANY program.

The question the program is to answer is "Does the program represented
by the input to the decider Halt when run?"

Since you stipulate that H(D,D) WILL return 0 (and incorrectly claim
this to be correct) a simple analysis of the code of D shows that it
WILL halt. in part BECAUSE H(D,D) return 0.

Thus, the CORRECT answer is Halt.

THe answer given by H was Non-Halting, and thus is WRONG.

The Liar Paradox cannot be correctly resolved to a value of True or
False only because it is semantically unsound because it is self- contradictory.

But since the answer to the question HAS an actual answer, it isn't an equivalent to the liar's paradox.

Your alternate quesition, what can be build an H to return for this
case, IS an equivalent to the liars paradox, which doesn't make the
original question of the Halting Problem invalid, it just shows that we
can't actually build such a machine (at least by the method you are investigating) and thus just provides support (or proves if you clean
things up a bit) that the Halting Function is non-computable and thus we
can not make a program that answers the Halting Problem.

Thus the inability of a termination analyzer to provide a correct
Boolean return value is analogous to a CAD system's inability to
correctly draw a square circle. Thus this interpretation of the halting problem is merely an artificial contrivance with no actual merit.

So, you AGREE that it is impossible to build a program to answer the
Halting Problem?

Then way do you say you have disproved the very thing you agreed with?

You seem to be confused.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/27/2023 12:13 PM, olcott wrote:

On 8/27/2023 10:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be non- >>> halting.

We can know that D correctly simulated by H must have different behavior >>> than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship
between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function
to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

H correctly determines that D correctly simulated by H cannot possibly
terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

(5) Of the infinite set of every possible H where D is correctly
simulated by H there are only a THREE categories of possible
behaviors for H:  (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:
   (a) Return 0 indicating that D correctly simulated by H cannot
       possibly terminate normally.

   (b) Return 1 indicating that D correctly simulated by H will
       terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which
of these options are incorrect on the basis of the source-code of D.

When a termination analyzer is required to provide the halt status or an
input that deliberately contradicts whatever Boolean value that this termination analyzer returns the halting problem merely mirrors the Liar Paradox.

The Liar Paradox cannot be correctly resolved to a value of True or
False only because it is semantically unsound because it is self- contradictory.

Thus the inability of a termination analyzer to provide a correct
Boolean return value is analogous to a CAD system's inability to
correctly draw a square circle. Thus this interpretation of the halting
problem is merely an artificial contrivance with no actual merit.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/27/2023 2:31 PM, olcott wrote:

On 8/27/2023 12:13 PM, olcott wrote:

On 8/27/2023 10:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem
proof's pathological relationship to simulating termination analyzer H. >>>> When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be
non-
halting.

We can know that D correctly simulated by H must have different
behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship >>>> between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what >>>> H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function >>>> to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06. >>>>
H correctly determines that D correctly simulated by H cannot possibly >>>> terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in
main() then the actual D that H is actually simulating will crash from
stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and
return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

(5) Of the infinite set of every possible H where D is correctly
simulated by H there are only a THREE categories of possible
behaviors for H:  (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:
    (a) Return 0 indicating that D correctly simulated by H cannot
        possibly terminate normally.

    (b) Return 1 indicating that D correctly simulated by H will
        terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which
of these options are incorrect on the basis of the source-code of D.

When a termination analyzer is required to provide the halt status or an input that deliberately contradicts whatever Boolean value that this termination analyzer returns the halting problem merely mirrors the Liar Paradox.

The Liar Paradox cannot be correctly resolved to a value of True or
False only because it is semantically unsound because it is self- contradictory.

Thus the inability of a termination analyzer to provide a correct
Boolean return value is analogous to a CAD system's inability to
correctly draw a square circle. Thus this interpretation of the halting problem is merely an artificial contrivance with no actual merit.

This is "undecidable" in the same way that finding an
N such that N > 5 and N < 2 is "undecidable".

When a termination analyzer must return a Boolean value that provides
the halt status of and D does the opposite of whatever Boolean value
that H returns the halting problem is a mere ruse and not any legitimate decision problem at all.

This only happens when we expect H to determine the halt status of a
non-input.

int sum(int x, int y)
{
return x + y;
}

When for forbid H to report on not inputs this is the same as
forbidding sum(3,4) to report on the sum of 5 + 7.

When for forbid H to report on not inputs then the halting problem counter-example is decidable by a simulating termination analyzer.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 8/28/23 11:05 AM, olcott wrote:

On 8/27/2023 2:31 PM, olcott wrote:

On 8/27/2023 12:13 PM, olcott wrote:

On 8/27/2023 10:00 AM, olcott wrote:

On 8/25/2023 1:48 PM, olcott wrote:

A pair of C functions are defined such that D has the halting problem >>>>> proof's pathological relationship to simulating termination
analyzer H.
When it is understood that D correctly simulated by H (a) Is the
behavior that H must report on and (b) Cannot possibly terminate
normally then it is understood that D is correctly determined to be
non-
halting.

We can know that D correctly simulated by H must have different
behavior
than D(D) directly executed in main() because we can see (in its
execution trace shown below) exactly how the pathological relationship >>>>> between D and H changes the behavior of D relative to H.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of
what
H predicts D will do. No H can exist that handles this case.
https://en.wikipedia.org/wiki/Halting_problem

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Can D correctly simulated by H terminate normally?
The x86utm operating system: https://github.com/plolcott/x86utm
is based on an open source x86 emulator. x86utm enables one C function >>>>> to execute another C function in debug step mode.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input >>>>> 03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D) >>>>>
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06. >>>>>
H correctly determines that D correctly simulated by H cannot possibly >>>>> terminate normally on the basis that H recognizes a dynamic behavior >>>>> pattern equivalent to infinite recursion. H returns 0 this basis.

*ADDENDUM*

(1) The source-code of H and D conclusively proves that D correctly
simulated by H cannot possibly terminate normally.

*THIS IS THE PART THAT EVERYONE LIES ABOUT*
(2) The correct simulation of D by H must include the fact that
D would continue to call H until stack overflow crash unless H
aborts its simulation of D.

(3) (2) Means that D is correctly simulated by H and this correctly
simulated D is non-halting.

(4) "A decision problem is a yes-or-no question on an infinite set
of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition >>>>> This means that the behavior of non-inputs is not allowed to be
considered.

If H ignores reality (not a good idea) and [as most of my reviewers
believe] makes pretend that it is simulating D(D) directly executed in >>>> main() then the actual D that H is actually simulating will crash from >>>> stack overflow because H will never stop simulating D.

This conclusively proves that D is correct to abort its simulation and >>>> return 0 indicating that D correctly simulated by H cannot possibly
terminate normally.

(5) Of the infinite set of every possible H where D is correctly
simulated by H there are only a THREE categories of possible
behaviors for H:  (1)(a), (1)(b) and (2)

(1) Abort its simulation of D after a finite number of steps:
    (a) Return 0 indicating that D correctly simulated by H cannot
        possibly terminate normally.

    (b) Return 1 indicating that D correctly simulated by H will
        terminate normally.

(2) Never abort its simulation of D.

Anyone having a sufficient knowledge of C can correctly determine which
of these options are incorrect on the basis of the source-code of D.

When a termination analyzer is required to provide the halt status or an
input that deliberately contradicts whatever Boolean value that this
termination analyzer returns the halting problem merely mirrors the Liar
Paradox.

The Liar Paradox cannot be correctly resolved to a value of True or
False only because it is semantically unsound because it is self-
contradictory.

Thus the inability of a termination analyzer to provide a correct
Boolean return value is analogous to a CAD system's inability to
correctly draw a square circle. Thus this interpretation of the halting
problem is merely an artificial contrivance with no actual merit.

This is "undecidable" in the same way that finding an
N such that N > 5 and N < 2 is "undecidable".

Nope. Because the correct answer for the H you have provided exists, it
is Halting, BECAUSE your H answers non-halting, and THAT H always will
as that is the only thing THAT H can do as that is what it is programmed
to do. So THIS H is just wrong, the problem isn't "undecidabe"

If you want to try to create an other H that answers Halting for the D
built on it, that OTHER D will just go into a loop and be non-halting,
so that other H is also wrong.

If you make even another H that doesn't abort its simulation, it will
just be wrong by not answering.

Note, you don't even HAVE a "Halting Question" to answer until you
actauly define your Halt Decider, so the problem that is "undecidable"
can't be the "Halting Problem", as it doesn't exist until we have the
input program, and we can't have the program "D" until we have the
program H, fully defined, and at that point, the answer exists (as
described above).

So, the only "undecidable" question you are talking about is one that
isn't the Halting Problem, so you logic is just unsound.

When a termination analyzer must return a Boolean value that provides
the halt status of and D does the opposite of whatever Boolean value
that H returns the halting problem is a mere ruse and not any legitimate decision problem at all.

Right, and it just can't because the problem is non-computable, not that
it doesn't have an answer.

This only happens when we expect H to determine the halt status of a non-input.

Nope, The Behavior of D(D) IS the input, or your H isn't a Halt Decider.

You are just proving you don't understand what you are talking about.

int sum(int x, int y)
{
  return x + y;
}

When for forbid H to report on not inputs this is the same as
forbidding sum(3,4) to report on the sum of 5 + 7.

Who is forbiding H from reporting on the behavior of the input? It is
perfectly free to give what ever answer it wants (as long as that it
swhat is has been programmed to do, as all programs onlygive the answers
they have been programmed to do). The only issue is that, becaus the
input is build on using a copy of the decider, as ALLOWED by the theory
of computability, that answer will justbe wrong.

Remember, "Get the right answer" is NOT a "program", but you need to
actually find (if it is possible) a computation that generates the right answer.

When for forbid H to report on not inputs then the halting problem counter-example is decidable by a simulating termination analyzer.

But the behavior of the machine represented by the input IS the behavior
of the input for a Halt Decider, so you are just admitting that you are
lying that your H actually is a Halt Decider.

Thus, you are admitting that you are just wrong.

But are too stupid to know what you are talking about.

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)