When it is understood that D correctly simulated by H is the behavior
that H must report on then the halting problem's otherwise impossible
input 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.

*Can D correctly simulated by H terminate normally*
The x86utm operating system based on an open source x86 emulator. This
system 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.

*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

On 8/23/23 12:00 AM, olcott wrote:
> When it is understood that D correctly simulated by H is the behavior
> that H must report on then the halting problem's otherwise impossible
> input is correctly determined to be non-halting.

You STILL don't get it do you!!

Your H DOESN'T correctly simulate its input, thus you are just showing
yourself to be a STUPID LIAR.

You don't even seem to understand that programs do what they are
actually programmed to do, not just what you want them to do.

>
> 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.

How? Sinrr H DOESN'T correctly simulate its input.

We can tell that as its simulation differs from the ACTUAL Correct
Simulation of this input that you previously posted.

So, it seems that you thing two things that are different can be called
the same.

>
> *Can D correctly simulated by H terminate normally*

WHO CARES?

Since H doesn't actually correctly simulate its input, it doesn't matter
what some other machine that goes by the name H does.

This is just like your "famous" questions about arresting the twin.

You are just showing how stupid you are.

> The x86utm operating system based on an open source x86 emulator. This
> system enables one C function to execute another C function in debug
> step mode.

Yes, and that shows that the COPRRECT simulation of the input to H stops.

Thus you are just a pathetic liar to say that H's correct simulation
show it doesn't

>
> // 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)

Nope, the H that D calls aborts its simulation as that is what itis
programmed to do.

You are just admitting to being a liar.

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

Nope. LIES.

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

So?

An H that correctly simulates the D built on it never answers, so fails
to be a decider.

>
>
> *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 your proof of your stupidity.
>

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

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.

On 8/22/2023 5:16 AM, Mikko wrote:
> On 2023-08-21 14:54:19 +0000, olcott said:
>
>> On 8/21/2023 5:54 AM, Mikko wrote:
>>> On 2023-08-20 16:06:32 +0000, olcott said:
>>>
>>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>>
>>>>>> If D correctly simulated by H cannot possibly terminate normally then
>>>>>> this proves that the actual behavior of the actual input is
>>>>>> non-halting.
>>>>>
>>>>> D correctly simulated by H does not even exist unless H correctly
>>>>> simulates
>>>>> D. However, there is not need to say anything about "D correctly
>>>>> simulated
>>>>> by H" because pain "D" is sufficient.
>>>>>
>>>>> H's simulation of D is another thing. It is not the same as D although
>>>>> there is some similarity if H simulates correctly.
>>>>>
>>>>>> A halt decider is required to report on the actual behavior of the
>>>>>> actual input and it not allowed to report on any other behavior.
>>>>>
>>>>> A decider is required to tell whether a text is of the kind that
>>>>> the decider is required to identify. For a halt decider the
>>>>> requirement
>>>>> is that the text is a description of a halting computation.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>
>>>> *Thu 10/13/2022 11:29 AM email from*
>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>> words are correct (he has not agreed to anything else):
>>>
>>>> If simulating halt decider H correctly simulates its input D until H
>>>> correctly determines that its simulated D would never stop running
>>>> unless
>>>> aborted then H can abort its simulation of D and correctly report
>>>> that D
>>>> specifies a non-halting sequence of configurations.
>>>
>>> His opinion is that this statement is true. However, his opinion is not
>>> a definition. If you want prove something, you must start with
>>> definitons,
>>> not with opinions.
>>>
>>> Mikko
>>>
>>
>> He agreed with my verbatim words.
>
> An agreement of opionions is not a proof.
>
>> Many people noticed that these words are a tautology thus
>> a necessary truth.
>
> That is a semantic tautology, i.e., it is a tautology only if correctly
> interpreted.
>
>> When D correctly simulated by H cannot possibly terminate normally
>> and halting requires terminating normally then the D input to H
>> is necessarily non-halting.
>
> The D that H simulates does terminate normally. H just fails to simulate
> D to normal termination.
>
> Mikko
>

Anyone that knows this (fully operational)
code well enough knows that D correctly
simulated by H cannot possibly terminate
normally.

We must simulate the pathological relationship
that is specified by the source code or the
simulation is incorrect.

// 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.

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

On 8/24/23 2:41 AM, olcott wrote:
> On 8/22/2023 5:16 AM, Mikko wrote:
>> On 2023-08-21 14:54:19 +0000, olcott said:
>>
>>> On 8/21/2023 5:54 AM, Mikko wrote:
>>>> On 2023-08-20 16:06:32 +0000, olcott said:
>>>>
>>>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>>>
>>>>>>> If D correctly simulated by H cannot possibly terminate normally
>>>>>>> then
>>>>>>> this proves that the actual behavior of the actual input is
>>>>>>> non-halting.
>>>>>>
>>>>>> D correctly simulated by H does not even exist unless H correctly
>>>>>> simulates
>>>>>> D. However, there is not need to say anything about "D correctly
>>>>>> simulated
>>>>>> by H" because pain "D" is sufficient.
>>>>>>
>>>>>> H's simulation of D is another thing. It is not the same as D
>>>>>> although
>>>>>> there is some similarity if H simulates correctly.
>>>>>>
>>>>>>> A halt decider is required to report on the actual behavior of the
>>>>>>> actual input and it not allowed to report on any other behavior.
>>>>>>
>>>>>> A decider is required to tell whether a text is of the kind that
>>>>>> the decider is required to identify. For a halt decider the
>>>>>> requirement
>>>>>> is that the text is a description of a halting computation.
>>>>>>
>>>>>> Mikko
>>>>>>
>>>>>
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>
>>>>> *Thu 10/13/2022 11:29 AM email from*
>>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>>> words are correct (he has not agreed to anything else):
>>>>
>>>>> If simulating halt decider H correctly simulates its input D until H
>>>>> correctly determines that its simulated D would never stop running
>>>>> unless
>>>>> aborted then H can abort its simulation of D and correctly report
>>>>> that D
>>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> His opinion is that this statement is true. However, his opinion is not
>>>> a definition. If you want prove something, you must start with
>>>> definitons,
>>>> not with opinions.
>>>>
>>>> Mikko
>>>>
>>>
>>> He agreed with my verbatim words.
>>
>> An agreement of opionions is not a proof.
>>
>>> Many people noticed that these words are a tautology thus
>>> a necessary truth.
>>
>> That is a semantic tautology, i.e., it is a tautology only if correctly
>> interpreted.
>>
>>> When D correctly simulated by H cannot possibly terminate normally
>>> and halting requires terminating normally then the D input to H
>>> is necessarily non-halting.
>>
>> The D that H simulates does terminate normally. H just fails to simulate
>> D to normal termination.
>>
>> Mikko
>>
>
> Anyone that knows this (fully operational)
> code well enough knows that D correctly
> simulated by H cannot possibly terminate
> normally.

No, your "fully operational" code shows that you don't understand what
correctly simulated means, or what it means for something to be a
"program", and are just a liar.

H, is a SPECIFIC program with SPECIFIC behavior for any given input.

>
> We must simulate the pathological relationship
> that is specified by the source code or the
> simulation is incorrect.

Right, which means to CORRECTLY SIMULATE the input, we must include the
effect of the "pathological" relationship, which means that since H
aborts its simulation and return, we must take that into account, which
because of the pathology, H does not.

>
> // 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.

It NEVER repeats because your actual H aborts immediately

IT is a ERROR and a LIE to talk about "potential" behavior that doesn't
actually occur. That just shows your stupidity and that you are just a liar.

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

No, the ACTUAL behavior seen is:

Simulated D(D) invokes a simulated H(D,D), which YOUR H just aborts when
it sees it, but if CORRECTLY simulated (because for that now know
behavior) that simulated H would be simulated simulating D until it sees
D call H, at which point the simulated H would abort its simulation and
return 0 to the simualted D which then Halts.

This is the ACTUAL "correct simulation" of the input, because that is
the actual behavior when run. It shows that a H waa just not correct in
its analysis, in part because it is IMPOSSIBLE for H to be correct due
to the "Pathological" relationship.

Impossible is an allowed state. The ACTUAL question, "Does the input
represent a Halting Computation?" has a correct answer, it is just
impossible to build a machine that gives the correct answer for the
input built on itself in this manner. Nothing wrong with that, there are
infinitely many more mappings we can try to compute, then computations
that can do those mappings, so most mappings just can't be computed.
Halting is just one of them.

You seem to think that if something is impossible to do, you get to
change the rules. That idea just makes you a pathological liar, because
you don't even understand what Truth means.

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

So, you don't understand what an "invariant" actually means, and are
just puttiong out "word salad"

>
> 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, you are just asserting that an incorrecrt answer must be correct
because you are a pathological liar.

H INCORRECTLY determines that if D was correctly simulated it would
never return, because H INCORRECTLY presume that H won't return until it
does a correct simulation. Since H doesn't do that, it is using a false
premise, and you are proving you just don't understand how logic works.

You keep on making these mistakes, because you fundamentally don't
understand how logic works. A guess you just have a pathology of the
brain that makes it so you can't think straight,

It seems you think you can change the core rules, and then just assume
things work the way you want.

Your world is just a world of broken logic filled with errors, that you
are just incapable of seeing.

On 8/22/2023 5:16 AM, Mikko wrote:
> On 2023-08-21 14:54:19 +0000, olcott said:
>
>> On 8/21/2023 5:54 AM, Mikko wrote:
>>> On 2023-08-20 16:06:32 +0000, olcott said:
>>>
>>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>>
>>>>>> If D correctly simulated by H cannot possibly terminate normally then
>>>>>> this proves that the actual behavior of the actual input is
>>>>>> non-halting.
>>>>>
>>>>> D correctly simulated by H does not even exist unless H correctly
>>>>> simulates
>>>>> D. However, there is not need to say anything about "D correctly
>>>>> simulated
>>>>> by H" because pain "D" is sufficient.
>>>>>
>>>>> H's simulation of D is another thing. It is not the same as D although
>>>>> there is some similarity if H simulates correctly.
>>>>>
>>>>>> A halt decider is required to report on the actual behavior of the
>>>>>> actual input and it not allowed to report on any other behavior.
>>>>>
>>>>> A decider is required to tell whether a text is of the kind that
>>>>> the decider is required to identify. For a halt decider the
>>>>> requirement
>>>>> is that the text is a description of a halting computation.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>
>>>> *Thu 10/13/2022 11:29 AM email from*
>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>> words are correct (he has not agreed to anything else):
>>>
>>>> If simulating halt decider H correctly simulates its input D until H
>>>> correctly determines that its simulated D would never stop running
>>>> unless
>>>> aborted then H can abort its simulation of D and correctly report
>>>> that D
>>>> specifies a non-halting sequence of configurations.
>>>
>>> His opinion is that this statement is true. However, his opinion is not
>>> a definition. If you want prove something, you must start with
>>> definitons,
>>> not with opinions.
>>>
>>> Mikko
>>>
>>
>> He agreed with my verbatim words.
>
> An agreement of opionions is not a proof.
>
>> Many people noticed that these words are a tautology thus
>> a necessary truth.
>
> That is a semantic tautology, i.e., it is a tautology only if correctly
> interpreted.
>
>> When D correctly simulated by H cannot possibly terminate normally
>> and halting requires terminating normally then the D input to H
>> is necessarily non-halting.
>
> The D that H simulates does terminate normally. H just fails to simulate
> D to normal termination.
>
> Mikko
>

*All of my reviews have been specifically counter-factual*

The source-code of D and H proves that D correctly simulated
by H cannot possibly terminate normally because D continues
to call H in recursive simulation unless the system crashes
because of stack overflow or H aborts its simulation of D.

When D is correctly simulated by H the source-code of D and H
requires that the pathological relationship that D defines
with H must be simulated.

All of my reviewers simply counter-factually ignore what the
source-code specifies. This is either incompetent or dishonest.

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

On 8/24/23 1:47 PM, olcott wrote:
> On 8/22/2023 5:16 AM, Mikko wrote:
>> On 2023-08-21 14:54:19 +0000, olcott said:
>>
>>> On 8/21/2023 5:54 AM, Mikko wrote:
>>>> On 2023-08-20 16:06:32 +0000, olcott said:
>>>>
>>>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>>>
>>>>>>> If D correctly simulated by H cannot possibly terminate normally
>>>>>>> then
>>>>>>> this proves that the actual behavior of the actual input is
>>>>>>> non-halting.
>>>>>>
>>>>>> D correctly simulated by H does not even exist unless H correctly
>>>>>> simulates
>>>>>> D. However, there is not need to say anything about "D correctly
>>>>>> simulated
>>>>>> by H" because pain "D" is sufficient.
>>>>>>
>>>>>> H's simulation of D is another thing. It is not the same as D
>>>>>> although
>>>>>> there is some similarity if H simulates correctly.
>>>>>>
>>>>>>> A halt decider is required to report on the actual behavior of the
>>>>>>> actual input and it not allowed to report on any other behavior.
>>>>>>
>>>>>> A decider is required to tell whether a text is of the kind that
>>>>>> the decider is required to identify. For a halt decider the
>>>>>> requirement
>>>>>> is that the text is a description of a halting computation.
>>>>>>
>>>>>> Mikko
>>>>>>
>>>>>
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>
>>>>> *Thu 10/13/2022 11:29 AM email from*
>>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>>> words are correct (he has not agreed to anything else):
>>>>
>>>>> If simulating halt decider H correctly simulates its input D until H
>>>>> correctly determines that its simulated D would never stop running
>>>>> unless
>>>>> aborted then H can abort its simulation of D and correctly report
>>>>> that D
>>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> His opinion is that this statement is true. However, his opinion is not
>>>> a definition. If you want prove something, you must start with
>>>> definitons,
>>>> not with opinions.
>>>>
>>>> Mikko
>>>>
>>>
>>> He agreed with my verbatim words.
>>
>> An agreement of opionions is not a proof.
>>
>>> Many people noticed that these words are a tautology thus
>>> a necessary truth.
>>
>> That is a semantic tautology, i.e., it is a tautology only if correctly
>> interpreted.
>>
>>> When D correctly simulated by H cannot possibly terminate normally
>>> and halting requires terminating normally then the D input to H
>>> is necessarily non-halting.
>>
>> The D that H simulates does terminate normally. H just fails to simulate
>> D to normal termination.
>>
>> Mikko
>>
>
> *All of my reviews have been specifically counter-factual*
>
> The source-code of D and H proves that D correctly simulated
> by H cannot possibly terminate normally because D continues
> to call H in recursive simulation unless the system crashes
> because of stack overflow or H aborts its simulation of D.

No, it PROVES that if H(D,D) returns 0 the D(D) will halt.

Since H(D,D) DOES return 0, then we have proof that the correct
simulation of the input to H will halt, and thus H is wrong.

Yes, we can show that if we had some other H that actually does a
correct simulation of its input, then the other D that is built from
that H will be non-halting, but also that such an other H will never
return an answer.

Since that is a DIFFERENT input, it doesn't appply hear, and you are
just proving you don't understand anything about what you are talking
about. If is just fabrication to talk about a program doing behavior
that it doesn't do, but apparently that is the only sort of logic you
can do. You are just proving you are a LIAR.

>
> When D is correctly simulated by H the source-code of D and H
> requires that the pathological relationship that D defines
> with H must be simulated.

So, you think that if we assume the moon is made of green cheese, we can
show that the moon is edible.

THe problem with your logic is that H DOESN'T "correctly simulate" D, so
if you make that a premise to your arguement, you are just showing you
are unsound.

>
> All of my reviewers simply counter-factually ignore what the
> source-code specifies. This is either incompetent or dishonest >

Nope, you are just proving your stupidity, not understanding how your
own code works or what the words you are using actually mean.

You have killed you reputation and will only be remembered as aan
ignorant pathological liar.

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

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.

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

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
>

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

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
>>
>

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

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
>>>
>>
>

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

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.