The execution trace of D correctly simulated by H proves that D cannot
possibly terminate normally. When H is required to report on the actual
behavior of its input it must reject D as non-halting.

This same requirement also forbids H to report on the behavior of the
non-input D(D) directly executed in main(). These same ideas are also
applied to the Peter Linz Turing Machine based halting problem proof.

"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 based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// 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 outputs: "H: Infinitely Recursive Simulation Detected Simulation
Stopped" indicating that D has defined a pathological (see above)
relationship to H.

*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/4/23 6:44 PM, olcott wrote:
> The execution trace of D correctly simulated by H proves that D cannot
> possibly terminate normally. When H is required to report on the actual
> behavior of its input it must reject D as non-halting.

Does H "Correctly Simulate" its input?, and give ann answer?

HOW?

You H just fails to be a compuation if you try to define that it does
so, as it doesn't always do the same thing for a given input, and you
are thus just admitting to being a LIAR.

>
> This same requirement also forbids H to report on the behavior of the
> non-input D(D) directly executed in main(). These same ideas are also
> applied to the Peter Linz Turing Machine based halting problem proof.

Except if D(D) isn't the "input" to H, then you are LY(NG that H is a
"Halt Decider", as BY DEFINITION, the input to a Halt decider is the
description of the machine that it is to decide about, and that would be
D(D) in 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 for the HALTING PROBLEM, that "yes-or-no question" is based on the
behavior of the computation described by the input to the decider.

>
> Can D correctly simulated by H terminate normally?

Which isn't the question of the Halting Problem, so AGIAN, you are just
admitting that you ar just a pathological liar about what you are doing.

You seem to think you can answer the WRONG question and claim to be right.

> 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. When H simulates D it creates a separate process context for
> D with its own memory, stack and virtual registers. H is able to
> simulate D simulating itself, thus the only limit to recursive
> simulations is RAM.

SO?

If it doesn't give the answer to the REQUIRED question, it just is wrong.

Remember THE DEFINTION of the Halting Problem is the question can we
design a computation that can answer for ANY possible computation
described to it, it that computation will finish in finite time (number
of steps), so the question to the computation is what is the behavior of
the computation described by its input.

If H(D,D) isn't asking about D(D), what does, of are you just admitting
that you are 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)
> 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 outputs: "H: Infinitely Recursive Simulation Detected Simulation
> Stopped" indicating that D has defined a pathological (see above)
> relationship to H.
>
> *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
>
>
>

Which since D(D) will Halt when run, and that is the behavior that the
Halting Problem is asking about, so you claim that this CAN'T be what
your H is being asked about just means you are just ADMITTING that you
are LYING about working on the Halting Problem.

Your "Logic" just prove that you are TOTALLY IGNORANT of what you are
claiming to be talking about.

Ultimately, you are just proving the following facts about your self:

1) you are totally ignorant of the actual definition of the problem you
claim to be working on, and just ignore when people correct you, meaning
your errors are not "honest mistakes"

2) you are intentionally decpetive about your claims, using incorrect
definitions of terms for the context that they are being used in.

1) you are just a pathological liar, as you claim things that are
clearly not true. It can't be an "Honest Mistake" as you repeat the
errors when correct.

4) You are showing your idiodicy by the fact that you keep repeating
your errors, thinking that by just repeating them enough you might make
people think they are true. (Which is one of the definitions of a "Big Lie")

5) This also says you match one of the defintions of Insanity.

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

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. The halting
problem question is only contradictory when a halt decider must divide
arbitrary finite string pairs (including non-inputs) into those that
halt on their input and those that do not. When we exclude non-inputs
then the contradiction is unreachable by D correctly simulated by H thus
has no effect.

The execution trace of D correctly simulated by H proves that this D
cannot possibly terminate normally. When H is required to report on the
actual behavior of its input it must reject D as non-halting. This same
requirement also forbids H to report on the (differing) behavior of the
non-input D(D) directly executed in main(). These same ideas are also
applied to the Peter Linz Turing Machine based halting problem proof
(shown below).

"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 based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// 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/5/2023 12:59 PM, olcott wrote:
> *Termination Analyzer H is Not Fooled by Pathological Input D*
>
> When the halting problem is construed as requiring a correct yes/no
> answer to a contradictory question it cannot be solved. The halting
> problem question is only contradictory when a halt decider must divide
> arbitrary finite string pairs (including non-inputs) into those that
> halt on their input and those that do not. When we exclude non-inputs
> then the contradiction is unreachable by D correctly simulated by H thus
> has no effect.
>
> The execution trace of D correctly simulated by H proves that this D
> cannot possibly terminate normally. When H is required to report on the
> actual behavior of its input it must reject D as non-halting. This same
> requirement also forbids H to report on the (differing) behavior of the
> non-input D(D) directly executed in main(). These same ideas are also
> applied to the Peter Linz Turing Machine based halting problem proof
> (shown below).
>
> "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 based on an open source x86 emulator. This
> system enables one C function to execute another C function in debug
> step mode. When H simulates D it creates a separate process context for
> D with its own memory, stack and virtual registers. H is able to
> simulate D simulating itself, thus the only limit to recursive
> simulations is RAM.
>
> // 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

All rebuttals in the last two years have been specifically counter-
factual. The key dishonest rebuttal in the last two years is that D(D)
executed from main() <is> an input parameter to H(D,D).

This lie is promoted because the liars know that deciders only operate
on inputs.

The other key dishonest rebuttal is that the actual correct execution
trace of D correctly simulated by H (shown above) is not the actual
correct execution trace of D correctly simulated by H.

What moron thinks that they can get away with claiming that a thing is
not itself?

--
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/5/23 4:14 PM, olcott wrote:
> On 8/5/2023 12:59 PM, olcott wrote:
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>
>> When the halting problem is construed as requiring a correct yes/no
>> answer to a contradictory question it cannot be solved. The halting
>> problem question is only contradictory when a halt decider must divide
>> arbitrary finite string pairs (including non-inputs) into those that
>> halt on their input and those that do not. When we exclude non-inputs
>> then the contradiction is unreachable by D correctly simulated by H
>> thus has no effect.
>>
>> The execution trace of D correctly simulated by H proves that this D
>> cannot possibly terminate normally. When H is required to report on
>> the actual behavior of its input it must reject D as non-halting. This
>> same requirement also forbids H to report on the (differing) behavior
>> of the non-input D(D) directly executed in main(). These same ideas
>> are also applied to the Peter Linz Turing Machine based halting
>> problem proof (shown below).
>>
>> "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 based on an open source x86 emulator. This
>> system enables one C function to execute another C function in debug
>> step mode. When H simulates D it creates a separate process context
>> for D with its own memory, stack and virtual registers. H is able to
>> simulate D simulating itself, thus the only limit to recursive
>> simulations is RAM.
>>
>> // 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
>
> All rebuttals in the last two years have been specifically counter-
> factual. The key dishonest rebuttal in the last two years is that D(D)
> executed from main() <is> an input parameter to H(D,D).

Nope, All your arguements have been because you don't know the actual
meaning of the words you are using.

>
> This lie is promoted because the liars know that deciders only operate
> on inputs.
>
> The other key dishonest rebuttal is that the actual correct execution
> trace of D correctly simulated by H (shown above) is not the actual
> correct execution trace of D correctly simulated by H.

Sinxe it isn't a "Correct Simulation" of the actual execution of the
machine, your statement is just a LIE,.

>
> What moron thinks that they can get away with claiming that a thing is
> not itself?
>
>

So, you ADMIT your statment is a LIE?

Remember, CORRECT SIMULATION means match the ACTUAL THING, that is the
machine being simulated.

You just don't undrstand basic English.

On 8/5/23 1:59 PM, olcott wrote:
> *Termination Analyzer H is Not Fooled by Pathological Input D*
>
> When the halting problem is construed as requiring a correct yes/no
> answer to a contradictory question it cannot be solved. The halting
> problem question is only contradictory when a halt decider must divide
> arbitrary finite string pairs (including non-inputs) into those that
> halt on their input and those that do not. When we exclude non-inputs
> then the contradiction is unreachable by D correctly simulated by H thus
> has no effect.
>
> The execution trace of D correctly simulated by H proves that this D
> cannot possibly terminate normally. When H is required to report on the
> actual behavior of its input it must reject D as non-halting. This same
> requirement also forbids H to report on the (differing) behavior of the
> non-input D(D) directly executed in main(). These same ideas are also
> applied to the Peter Linz Turing Machine based halting problem proof
> (shown below).
>
> "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 based on an open source x86 emulator. This
> system enables one C function to execute another C function in debug
> step mode. When H simulates D it creates a separate process context for
> D with its own memory, stack and virtual registers. H is able to
> simulate D simulating itself, thus the only limit to recursive
> simulations is RAM.
>
> // 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
>
>
>
>
>

Just repeating the same errors, proving you to be insane.

The question is NOT "Contradictory" under the conditions required by the
problem, that the input be an actual computaiton.

ALL computation will either Halt or Not.

The only way the proof program isn't an actual computation is if the
claimed decider is not.

So, you are admitting that you whole proof is based on the LIE that your
decider meets the requirements.

YOU FAIL.

On 8/5/23 4:14 PM, olcott wrote:
> On 8/5/2023 12:59 PM, olcott wrote:
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>
>> When the halting problem is construed as requiring a correct yes/no
>> answer to a contradictory question it cannot be solved. The halting
>> problem question is only contradictory when a halt decider must divide
>> arbitrary finite string pairs (including non-inputs) into those that
>> halt on their input and those that do not. When we exclude non-inputs
>> then the contradiction is unreachable by D correctly simulated by H
>> thus has no effect.
>>
>> The execution trace of D correctly simulated by H proves that this D
>> cannot possibly terminate normally. When H is required to report on
>> the actual behavior of its input it must reject D as non-halting. This
>> same requirement also forbids H to report on the (differing) behavior
>> of the non-input D(D) directly executed in main(). These same ideas
>> are also applied to the Peter Linz Turing Machine based halting
>> problem proof (shown below).
>>
>> "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 based on an open source x86 emulator. This
>> system enables one C function to execute another C function in debug
>> step mode. When H simulates D it creates a separate process context
>> for D with its own memory, stack and virtual registers. H is able to
>> simulate D simulating itself, thus the only limit to recursive
>> simulations is RAM.
>>
>> // 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
>
> All rebuttals in the last two years have been specifically counter-
> factual. The key dishonest rebuttal in the last two years is that D(D)
> executed from main() <is> an input parameter to H(D,D).

So, you don't understand how a decider works?

Remember, the definition of the halt decider is that it decides on the
machine the input *REPRESENTS*

And, if the parameters for H(D,D) don't REPRESENT D(D), then what
computation is it suppose to REPRESENT, and how do you represent the
computaiton D(D).

Since you can't actually answer that question, your arguement is show to
just fall apart.

>
> This lie is promoted because the liars know that deciders only operate
> on inputs.

AND WHAT THEY REPRESENT.

Or, don't you understand "abstract" thinking.

>
> The other key dishonest rebuttal is that the actual correct execution
> trace of D correctly simulated by H (shown above) is not the actual
> correct execution trace of D correctly simulated by H.
>
> What moron thinks that they can get away with claiming that a thing is
> not itself?
>
>

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.

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

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. The halting
problem question is only contradictory when a halt decider must divide
arbitrary finite string pairs (including non-inputs) into those that
halt on their input and those that do not. When we exclude non-inputs
then the contradiction is unreachable by D correctly simulated by H thus
has no effect.

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. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// 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/11/23 5:29 PM, 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.
>
Except you are neglecting that THIS H doesn't "Correctly Simulate" its
input, so that statement is just a LIE.

There is NOTHING impossible about this input, as ANY actual correct
simulator will show that it is 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't be, because the DEFINITIOBN of a "Correct Simulation" is a
simulation the results in the exact behavior of the thing being simulated.

Since H is claimed to be a "Halt Decider", the machine "Described" by
its input is exactly "D(D)", so a "Correct Simulaiton" of that

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

But we dont' care about "Any program H", we care about THIS program H.

You are just proving that you don't understand the definitions.

>
> "A decision problem is a yes-or-no question on an infinite set of
> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
>
> When the halting problem is construed as requiring a correct yes/no
> answer to a contradictory question it cannot be solved. The halting
> problem question is only contradictory when a halt decider must divide
> arbitrary finite string pairs (including non-inputs) into those that
> halt on their input and those that do not. When we exclude non-inputs
> then the contradiction is unreachable by D correctly simulated by H thus
> has no effect.

What is "Contradictiory"? The answer to the qustion for ANY given
machine, even this "pathological" one has a definite answer. The
"pathology" doesn't make the answer indererminate, it just makes it that
no decider can give the correct answer for the input specifically
targeted to it, but other deciders have no problem.

>
> Can D correctly simulated by H terminate normally?

Since D ISN'T "correctly simulated by H, that is just another version of
the question "Have you stopped lying yet?" (well, have you?)

Now, if you make a DIFFERENT machine "D" off of a DIFFERENT machine "H"
that does actually correct simulate its input until it proves the
answer, then the answer is no, that "D" won't terminate, but it is also
true that the "H" won't answer ans thus fails to be a decider.

Since THIS "H" isn't THAT "H", the question is just irrelevent, and a
logical fallicy to bring up.

You just don't seem to understand the nature of what a program is.

> 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. When H simulates D it creates a separate process context for
> D with its own memory, stack and virtual registers. H is able to
> simulate D simulating itself, thus the only limit to recursive
> simulations is RAM.
>

Except that your code for H DOES'T actually "Correctly Simulate" its
input, since is assumes that a call to H(D,D) will not return, when it
does, since THIS H does abort and return.

Thus, it doesn't actually look at the ACTUAL input given to it, but
presumes H is something different than what it is.

And thus gets the WRONG answer.

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

But since H DOES abort, you need to take that into account.

The input does call an H that doesn't abort, but one that does..

Thus your H is just wrong about the behavior of the input.

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

You ate just looking at the wrong question, apparently because you are
too stupid to understand that actual qustion,

This just proves your stupidity.

You assert that a wrong answer is right, and thus your how basis of
ligic is proven to be incorrect. PERIOD.

It has EXPLODED, and you are just too dumb to realize it is dead.

On Friday, August 11, 2023 at 6:25:22 PM UTC-5, Richard Damon wrote:
> On 8/11/23 5:29 PM, 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.
> >
> Except you are neglecting that THIS H doesn't "Correctly Simulate" its
> input, so that statement is just a LIE.
>
> There is NOTHING impossible about this input, as ANY actual correct
> simulator will show that it is 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't be, because the DEFINITIOBN of a "Correct Simulation" is a
> simulation the results in the exact behavior of the thing being simulated..
>
> Since H is claimed to be a "Halt Decider", the machine "Described" by
> its input is exactly "D(D)", so a "Correct Simulaiton" of that
> >
> > 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
> But we dont' care about "Any program H", we care about THIS program H.
>
> You are just proving that you don't understand the definitions.
> >
> > "A decision problem is a yes-or-no question on an infinite set of
> > inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
> >
> > When the halting problem is construed as requiring a correct yes/no
> > answer to a contradictory question it cannot be solved. The halting
> > problem question is only contradictory when a halt decider must divide
> > arbitrary finite string pairs (including non-inputs) into those that
> > halt on their input and those that do not. When we exclude non-inputs
> > then the contradiction is unreachable by D correctly simulated by H thus
> > has no effect.
> What is "Contradictiory"? The answer to the qustion for ANY given
> machine, even this "pathological" one has a definite answer. The
> "pathology" doesn't make the answer indererminate, it just makes it that
> no decider can give the correct answer for the input specifically
> targeted to it, but other deciders have no problem.
> >
> > Can D correctly simulated by H terminate normally?
> Since D ISN'T "correctly simulated by H, that is just another version of
> the question "Have you stopped lying yet?" (well, have you?)
>
> Now, if you make a DIFFERENT machine "D" off of a DIFFERENT machine "H"
> that does actually correct simulate its input until it proves the
> answer, then the answer is no, that "D" won't terminate, but it is also
> true that the "H" won't answer ans thus fails to be a decider.
>
> Since THIS "H" isn't THAT "H", the question is just irrelevent, and a
> logical fallicy to bring up.
>
> You just don't seem to understand the nature of what a program is.
> > 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. When H simulates D it creates a separate process context for
> > D with its own memory, stack and virtual registers. H is able to
> > simulate D simulating itself, thus the only limit to recursive
> > simulations is RAM.
> >
> Except that your code for H DOES'T actually "Correctly Simulate" its
> input, since is assumes that a call to H(D,D) will not return, when it
> does, since THIS H does abort and return.
>
> Thus, it doesn't actually look at the ACTUAL input given to it, but
> presumes H is something different than what it is.
>
> And thus gets the WRONG answer.
> > // 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)
> But since H DOES abort, you need to take that into account.
>
> The input does call an H that doesn't abort, but one that does..
>
> Thus your H is just wrong about the behavior of the input.
> > 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
> >
> You ate just looking at the wrong question, apparently because you are
> too stupid to understand that actual qustion,
>
> This just proves your stupidity.
>
> You assert that a wrong answer is right, and thus your how basis of
> ligic is proven to be incorrect. PERIOD.
>
> It has EXPLODED, and you are just too dumb to realize it is dead.
Little Willy Willy won't go home and you can't make Willy leave. Willy won't go because this is the land it doesn't have to be you'll get there to buy tomorrow's breeze. It was brilliant in the flybut Lowe's in Juan and rolling in the wind time to watch Lassie.

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
>

*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