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.

On 2023-08-04 22:44:16 +0000, olcott said:

> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
> Stopped" indicating that D has defined a pathological (see above)
> relationship to H.

The answer is neither "no" nor "yes", so H is not a halt decider.
Perhaps it is a partial halt decider. Anayway it has no relevance
to the halting problem or computability questions.

Mikko

On 8/5/2023 8:10 AM, Mikko wrote:
> On 2023-08-04 22:44:16 +0000, olcott said:
>
>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>> Stopped" indicating that D has defined a pathological (see above)
>> relationship to H.
>
> The answer is neither "no" nor "yes", so H is not a halt decider.
> Perhaps it is a partial halt decider. Anayway it has no relevance
> to the halting problem or computability questions.
>
> Mikko
>

H returns 0 indicating that D correctly simulated by H cannot possibly
terminate normally. I will update my paper to make this more clear.

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

*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/2023 8:10 AM, Mikko wrote:
> On 2023-08-04 22:44:16 +0000, olcott said:
>
>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>> Stopped" indicating that D has defined a pathological (see above)
>> relationship to H.
>
> The answer is neither "no" nor "yes", so H is not a halt decider.
> Perhaps it is a partial halt decider. Anayway it has no relevance
> to the halting problem or computability questions.
>
> Mikko
>

I updated my paper because of your comment.

*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/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 10:43 AM, olcott wrote:
> On 8/5/2023 8:10 AM, Mikko wrote:
>> On 2023-08-04 22:44:16 +0000, olcott said:
>>
>>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>>> Stopped" indicating that D has defined a pathological (see above)
>>> relationship to H.
>>
>> The answer is neither "no" nor "yes", so H is not a halt decider.
>> Perhaps it is a partial halt decider. Anayway it has no relevance
>> to the halting problem or computability questions.
>>
>> Mikko
>>
>
> H returns 0 indicating that D correctly simulated by H cannot possibly
> terminate normally. I will update my paper to make this more clear.
>

So, you are admitting that H ISN'T a "Halting Decider", and you claim
that you have refuted the Halting Problem proof is just a LIE.

Either H is answering the ACTUAL Halting question, and is WRONG, or it
is answering some other question and not a Halt Decider.

Either way, you are proved to be and idiotic pathological liar.

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 7:55 PM, olcott wrote:
> On 8/5/2023 8:10 AM, Mikko wrote:
>> On 2023-08-04 22:44:16 +0000, olcott said:
>>
>>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>>> Stopped" indicating that D has defined a pathological (see above)
>>> relationship to H.
>>
>> The answer is neither "no" nor "yes", so H is not a halt decider.
>> Perhaps it is a partial halt decider. Anayway it has no relevance
>> to the halting problem or computability questions.
>>
>> Mikko
>>
>
> I updated my paper because of your comment.
>
> *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 effetively begins with an admittion that you aren't actually
working on the acutal Halting Problem because you don't understand it.

NO actual halting problem question doesn't have an actual Yes or No answer.

Only when the decide isn't actually a "Computation" but some
mytholotical construct that doesn't obey the rules do you get your problem.

You ADMIT this when you say:

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.

NO input is a "non-input" except one that doesn't represent an actual
computation.

The only way the "pathological" input doesn't represent an actual
computation is if the decider itself doesn't.

Thus, you are just admitting (though you show yourself to stupid to
understand it) that you decider just simply fails to meet the
requirements to ba an actual computation.

This is likely because you just don't understand what that word means in
this context.

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

On 8/5/2023 6:55 PM, olcott wrote:
> On 8/5/2023 8:10 AM, Mikko wrote:
>> On 2023-08-04 22:44:16 +0000, olcott said:
>>
>>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>>> Stopped" indicating that D has defined a pathological (see above)
>>> relationship to H.
>>
>> The answer is neither "no" nor "yes", so H is not a halt decider.
>> Perhaps it is a partial halt decider. Anayway it has no relevance
>> to the halting problem or computability questions.
>>
>> Mikko
>>
>
> I updated my paper because of your comment.
>
> *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
>
>

The reason that I did this in C/x86 is that it is impossible to
misconceive what is happening. With purely imaginary Turing machines
one can have a set of incoherent ideas and never notice.

In the C model of computation an input to a function must be passed on
the stack, thus making it impossible to confuse D(D) directly executed
in main() as an input to H(D,D).

It is also the case that D simulated by H and ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
embedded_H do demonstrate the actual behavior of these inputs relative
to their pathological relationships.

The D simulated by H has different behavior that D(D) directly executed
in main() because of their different placement in the execution trace.

The former one will never stop running unless aborted and the latter one
does stop running without being aborted.

--
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/6/2023 12:02 AM, olcott wrote, with header
Subject:
Re: Termination Analyzer H is Not Fooled by Pathological Input D

@PO
Stop anthropomorphizing Turing machines.
They don't like it.

On 8/6/23 12:02 AM, olcott wrote:
> On 8/5/2023 6:55 PM, olcott wrote:
>> On 8/5/2023 8:10 AM, Mikko wrote:
>>> On 2023-08-04 22:44:16 +0000, olcott said:
>>>
>>>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>>>> Stopped" indicating that D has defined a pathological (see above)
>>>> relationship to H.
>>>
>>> The answer is neither "no" nor "yes", so H is not a halt decider.
>>> Perhaps it is a partial halt decider. Anayway it has no relevance
>>> to the halting problem or computability questions.
>>>
>>> Mikko
>>>
>>
>> I updated my paper because of your comment.
>>
>> *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
>>
>>
>
> The reason that I did this in C/x86 is that it is impossible to
> misconceive what is happening. With purely imaginary Turing machines
> one can have a set of incoherent ideas and never notice.

Right, and D(D) WILL HALT since H(D,D) returns 0, showing that H is NOT
a "Halt Decider", and that you are just a pathological liar.

>
> In the C model of computation an input to a function must be passed on
> the stack, thus making it impossible to confuse D(D) directly executed
> in main() as an input to H(D,D).

And you don't understand the meaning of the word "representation", or
even "input"

>
> It is also the case that D simulated by H and ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by
> embedded_H do demonstrate the actual behavior of these inputs relative
> to their pathological relationships.

Just proves that you don't understand what reality or truth is.

>
> The D simulated by H has different behavior that D(D) directly executed
> in main() because of their different placement in the execution trace.

Which just means that H's "simulation" of D is not correct, by the
needed definition of "correct simulation" that would allow the
replacement of the direct execution by simulation.

You are just proving your ignorance.
>
> The former one will never stop running unless aborted and the latter one
> does stop running without being aborted.
>

But, since H DOES abort it, that is an irrelvent question.

You are just proving that you are and idiot.

You don't seem to understand that programs do what they are programmed
to do, and you can't talk about alternate behavior of a given program
without introducing a DIFFERENT program.

The thing is the thing that it is, not the thing you wish it to be.

On 8/6/2023 3:24 AM, Jim Burns wrote:
> On 8/6/2023 12:02 AM, olcott wrote, with header
> Subject:
> Re: Termination Analyzer H is Not Fooled by Pathological Input D
>
> @PO
> Stop anthropomorphizing Turing machines.
> They don't like it.

They tell me that the love being anthropomorphized it makes them feel
special.

--
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/6/23 10:23 AM, olcott wrote:
> On 8/6/2023 3:24 AM, Jim Burns wrote:
>> On 8/6/2023 12:02 AM, olcott wrote, with header
>> Subject:
>> Re: Termination Analyzer H is Not Fooled by Pathological Input D
>>
>> @PO
>> Stop anthropomorphizing Turing machines.
>> They don't like it.
>
> They tell me that the love being anthropomorphized it makes them feel
> special.
>
>

So, you admit to being crazy, and don't understand what a Computation is
or what a Turing Machine is.

Your writings are just proven to be the delusions of a mad man,

On 2023-08-05 14:43:44 +0000, olcott said:

> On 8/5/2023 8:10 AM, Mikko wrote:
>> On 2023-08-04 22:44:16 +0000, olcott said:
>>
>>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>>> Stopped" indicating that D has defined a pathological (see above)
>>> relationship to H.
>>
>> The answer is neither "no" nor "yes", so H is not a halt decider.
>> Perhaps it is a partial halt decider. Anayway it has no relevance
>> to the halting problem or computability questions.
>>
>> Mikko
>>
>
> H returns 0 indicating that D correctly simulated by H cannot possibly
> terminate normally. I will update my paper to make this more clear.

If you want to call H a "partial halt decider" or a "termination analyzer"
you shold demonstrate that
- H says "yes" for at least one P(I) that halts,
- H says "no" for at least one P(I) that runs forever,
- H does not say "yes" for any P(I) that runs forever, and
- H does not say "no" for any P(I) that halts.

Mikko

On 8/8/2023 4:36 AM, Mikko wrote:
> On 2023-08-05 14:43:44 +0000, olcott said:
>
>> On 8/5/2023 8:10 AM, Mikko wrote:
>>> On 2023-08-04 22:44:16 +0000, olcott said:
>>>
>>>> H outputs: "H: Infinitely Recursive Simulation Detected Simulation
>>>> Stopped" indicating that D has defined a pathological (see above)
>>>> relationship to H.
>>>
>>> The answer is neither "no" nor "yes", so H is not a halt decider.
>>> Perhaps it is a partial halt decider. Anayway it has no relevance
>>> to the halting problem or computability questions.
>>>
>>> Mikko
>>>
>>
>> H returns 0 indicating that D correctly simulated by H cannot possibly
>> terminate normally. I will update my paper to make this more clear.
>
> If you want to call H a "partial halt decider" or a "termination analyzer"
> you shold demonstrate that
> - H says "yes" for at least one P(I) that halts,
done
> - H says "no" for at least one P(I) that runs forever,
done
> - H does not say "yes" for any P(I) that runs forever, and
done
> - H does not say "no" for any P(I) that halts.
done
>
> Mikko
>
>

My H only has to correctly determine the halt status of the elements of
the template of the halting problem's "impossible" inputs to
conclusively refute all of the conventional halting problem proofs.

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

On 08/08/2023 15:00, olcott wrote:
> My H only has to correctly determine the halt status of the elements of
> the template of the halting problem's "impossible" inputs to
> conclusively refute all of the conventional halting problem proofs.

Is your H only a partial halt decider? If so, it does not give
rise to a paradoxical input, and you therefore have nothing of interest
to say about its status. Otherwise, by construction, there can be no
"impossible" input [which is why the conventional paradox works as a
contradiction]. You seem to think that some inputs are intrinsically
paradoxical; not so, they are only thus /in relation to/ an allegedly
complete and correct halt decider, which you have therefore to produce
first. I suggest you go back to the drawing board.

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Favarger

On 8/9/2023 7:23 AM, Andy Walker wrote:
> On 08/08/2023 15:00, olcott wrote:
>> My H only has to correctly determine the halt status of the elements of
>> the template of the halting problem's "impossible" inputs to
>> conclusively refute all of the conventional halting problem proofs.
>
>     Is your H only a partial halt decider?  If so, it does not give
> rise to a paradoxical input, and you therefore have nothing of interest
> to say about its status.

That is incorrect. D has defined the halting problem relationship 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

H correctly determines that D correctly simulated by H cannot possibly
terminate normally thus never halts.

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.

*The x86utm operating system* (includes several termination analyzers)
https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition
https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15

> Otherwise, by construction, there can be no
> "impossible" input [which is why the conventional paradox works as a
> contradiction].

D correctly simulated by H cannot possibly reach it own paradoxical
portion on line 07.

> You seem to think that some inputs are intrinsically
> paradoxical;  not so, they are only thus /in relation to/ an allegedly
> complete and correct halt decider, which you have therefore to produce
> first.  I suggest you go back to the drawing board.
>

I have been working on this since 2004 and there have been 30,000
reviews of my work since then in this forum.

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

On 09/08/2023 15:24, olcott wrote:
>>> My H only has to correctly determine the halt status of the elements of
>>> the template of the halting problem's "impossible" inputs to
>>> conclusively refute all of the conventional halting problem proofs.
>>      Is your H only a partial halt decider?  If so, it does not give
>> rise to a paradoxical input, and you therefore have nothing of interest
>> to say about its status.
> That is incorrect. D has defined the halting problem relationship to H.

But no-one cares. A partial decider can simply "pass" on any input
it can't decide about, however that input relates to H; so there is, and
can be, no paradox, and no "pathology". Your D is only "pathological" if
you claim that your H is a full and correct halt decider.

> 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

Yes, given an alleged decider, D is a program that shows that H
does not always give the correct answer. That is interesting only if
you claim that H always does give the correct answer. But you don't, so
your H is not interesting, no matter how often you list it.

> H correctly determines that D correctly simulated by H cannot possibly
> terminate normally thus never halts.

No-one [except perhaps you] cares. As H is not a full decider,
what it says about D is not interesting and has no relevance to the
halting problem.

> Can D correctly simulated by H terminate normally?

No-one cares ....

[...]>>  Otherwise, by construction, there can be no
>> "impossible" input [which is why the conventional paradox works as a
>> contradiction].
> D correctly simulated by H cannot possibly reach it own paradoxical
> portion on line 07.

No-one cares ....

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Favarger

On 8/9/2023 11:03 AM, Andy Walker wrote:
> On 09/08/2023 15:24, olcott wrote:
>>>> My H only has to correctly determine the halt status of the elements of
>>>> the template of the halting problem's "impossible" inputs to
>>>> conclusively refute all of the conventional halting problem proofs.
>>>      Is your H only a partial halt decider?  If so, it does not give
>>> rise to a paradoxical input, and you therefore have nothing of interest
>>> to say about its status.
>> That is incorrect. D has defined the halting problem relationship to H.
>
>     But no-one cares.  A partial decider can simply "pass" on any input
> it can't decide about, however that input relates to H;  so there is, and
> can be, no paradox, and no "pathology".  Your D is only "pathological" if
> you claim that your H is a full and correct halt decider.
>
>> 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
>
>     Yes, given an alleged decider, D is a program that shows that H
> does not always give the correct answer.

*You simply have not bothered to pay any attention at all*

That my H is not all knowing provides zero evidence that it did
not correctly determine the halt status of the halting problem's
pathological input.

I refuted all of the conventional proofs that solving the halting
problem is impossible.

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

D correctly simulated by H cannot possibly reach past its own line 06
thus never terminates normally thus never halts.

*No H can exist that handles this case* is refuted.

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

On 09/08/2023 17:24, olcott wrote:
> *You simply have not bothered to pay any attention at all*

Contrariwise, I have been bothering to pay you more attention
than you deserve. But like Ben and Andre', my patience is limited.

> That my H is not all knowing provides zero evidence that it did
> not correctly determine the halt status of the halting problem's
> pathological input.

If your H is not "all knowing", ie if it is not a halt decider
within the meaning of the Wiki article that you like to quote, then it
does not have a "pathological input". There is no such thing as "the
halting problem's pathological input", only a "pathological input" for
each program that purports to be a halt decider. Programs and problems
are not the same class of object.

> I refuted all of the conventional proofs that solving the halting
> problem is impossible.

Then I suggest that you submit your refutation to a reputable
journal and claim your fame and fortune, instead of wasting your time
here.

[...]
> D correctly simulated by H cannot possibly reach past its own line 06
> thus never terminates normally thus never halts.
> *No H can exist that handles this case* is refuted.

As your H is not a [full and correct] halt decider, your D is
not a refutation of the proof that H is not a halt decider, so there
is no "this case". The wording in the Wiki article is not as clear
as it should be, so I also suggest that you look elsewhere for other
similar proofs which might better suit. Wiki is not a reliable text-
book, especially if you insist on over-reading it too literally.

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Favarger

On 8/9/2023 1:44 PM, Andy Walker wrote:
> On 09/08/2023 17:24, olcott wrote:
>> *You simply have not bothered to pay any attention at all*
>
>     Contrariwise, I have been bothering to pay you more attention
> than you deserve.  But like Ben and Andre', my patience is limited.
>
>> That my H is not all knowing provides zero evidence that it did
>> not correctly determine the halt status of the halting problem's
>> pathological input.
>
>     If your H is not "all knowing", ie if it is not a halt decider
> within the meaning of the Wiki article that you like to quote, then it

That is correct

> does not have a "pathological input".  There is no such thing as "the

That is incorrect.

> halting problem's pathological input", only a "pathological input" for
> each program that purports to be a halt decider.  Programs and problems
> are not the same class of object.
>

This spec does not require an all knowing halt decider it only requires
a computer program. *YOU MUST BE PLAYING HEAD GAMES*

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

That I have show how H correctly determine that halt status of D refutes
all of the conventional proofs that claim this is always impossible.

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