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.

This exact same reasoning is shown to equally apply to the Peter Linz
Turing machine based halting problem proof.

*The correct simulation of D by H must include the call from D to H*
*that specifies that D calls H in recursive simulation*

Consistently all of the reviewers of my work insist that H must ignore
this recursive simulation and report that D(D) halts because when H does
not ignore this recursive simulation and aborts its simulation D(D) does
halt. *They have no idea that their view is inconsistent*

// 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 10/19/23 2:26 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.

Except you do it wrong, since by the actual proof, D gets a COPY of H,
as D needs to be a self-sufficient program by itself. Your arguement
that this can't be done just shows your system to not be Turing Complete
in the essential manner.

>
> When it is understood that D correctly simulated by H
> (a) Is the behavior that H must report on and

Then you are admitting H isn't working as a "Halt Decider" as a Halt
Decider MUST answer based on the ACTUAL BEHAVIOR of the program
REPRESENTED by the input.

Your Red Herring criteria just shows that you are either ignorant of the
actual problem, or just a deceptive liar trying to put one over. The
fact that you repeat the error after it has been pointed out, makes the
later most likely, and a stupid deceptive liar, as you are repeating a
lie that you know people know to be a lie.

This shows itself to just be a typical disinformation game. Your "Big Lie".

> (b) Cannot possibly terminate normally then it is understood that D is
> correctly determined to be non-halting.

But an actual "Correct Simulation" of the input does terminate normally,
it will see D call H, then H simulate its input, and abort it, then
return 0 to D and then D Halts.

The simulation that H aborted is a different process than the outer
simulation, so doesn't actually directly affect it, but only via what H
returns to its caller.

The fact that your H just gives up at that point, and assumed a
different behavior for the call, says that H did not correctly simulate
the call to H(D,D) correctly.

>
> This exact same reasoning is shown to equally apply to the Peter Linz
> Turing machine based halting problem proof.

Nope. Remember, Linz has H^ containing a copy of H, and thus, you can
give the H^ to any decider, and others can give the right answer.

"Correct Simulation" of an input is an invariant, it will always show
the same thing

>
> *The correct simulation of D by H must include the call from D to H*
> *that specifies that D calls H in recursive simulation*

And since H DOES abort its simulation, then a CORRECT SIMULATION of D
(by ANYONE, including H) must take that into account when it simulates D
calling H.

Since H's simulation does do that, calling H's simulation "correct" is
just a LIE.

>
> Consistently all of the reviewers of my work insist that H must ignore
> this recursive simulation and report that D(D) halts because when H does
> not ignore this recursive simulation and aborts its simulation D(D) does
> halt. *They have no idea that their view is inconsistent*

No, YOU are the one that claims that H needs to ignore that ACTUAL
behavior of H, and assume it does something it doesn't do (or is
something other than what it actually is).

In other words, you are LYING.

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

But since

void main()
{ D(D);
}

will halt, we see that the answer is incorrect.

Since that is the meaning of the input for H(D,D) if H is a halt decider.

All you are doing is trying to assert that Red Herrings are valid
logical reasoning, i.e. it is ok to lie when you do your logic.

Thus, you are proving yourself to be a liar and spreader of disinformation.

On 10/19/2023 1:26 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.
>
> This exact same reasoning is shown to equally apply to the Peter Linz
> Turing machine based halting problem proof.
>
> *The correct simulation of D by H must include the call from D to H*
> *that specifies that D calls H in recursive simulation*
>
> Consistently all of the reviewers of my work insist that H must ignore
> this recursive simulation and report that D(D) halts because when H does
> not ignore this recursive simulation and aborts its simulation D(D) does
> halt. *They have no idea that their view is inconsistent*
>
> // 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
>

It is a logical impossibility for any decider H to correctly report on
the behavior of the direct execution of an input D that does that
opposite of whatever Boolean value that H returns.

What no one has ever bothered to notice since 1936 is that the inability
to do the logically impossible never places any actual limitation on
anyone or anything.

They do understand the simpler case of this where the fact that no CAD
system can correctly draw a square circle doe not mean that computation
is limited.

The thing that trips them up is that some other decider H1 seems to be
able process the same input that H could not process.

They fail to understand that when H1 can provide a Boolean return value
for the direct execution of D and H cannot that even though they have
the same input

The question: Does your input halt on its input?
has a different meaning for H than it does for H1.

If two questions have different meanings then they are not the same
question.

Can Jack correctly answer “no” to this [yes/no] question?
is a has a different meaning for Jack than for anyone else.

Does input D halt on its input?
has a different meaning for H than for every other decider.

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

On 10/19/23 3:52 PM, olcott wrote:
> On 10/19/2023 1:26 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.
>>
>> This exact same reasoning is shown to equally apply to the Peter Linz
>> Turing machine based halting problem proof.
>>
>> *The correct simulation of D by H must include the call from D to H*
>> *that specifies that D calls H in recursive simulation*
>>
>> Consistently all of the reviewers of my work insist that H must ignore
>> this recursive simulation and report that D(D) halts because when H does
>> not ignore this recursive simulation and aborts its simulation D(D) does
>> halt. *They have no idea that their view is inconsistent*
>>
>> // 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
>>
>
> It is a logical impossibility for any decider H to correctly report on
> the behavior of the direct execution of an input D that does that
> opposite of whatever Boolean value that H returns.

Which is what makes such a decider impossible to make, not that the
question is illogical.

>
> What no one has ever bothered to notice since 1936 is that the inability
> to do the logically impossible never places any actual limitation on
> anyone or anything.

No, YOU are too stupid to understand how logic works.

There IS a correct asnwer, so the question is logical.

The fact that a given program gives the wrong answer just makes that
program wrong.

The fact that we can make such an input for every possible decider,
makes the problem non-computable, not invalid.

>
> They do understand the simpler case of this where the fact that no CAD
> system can correctly draw a square circle doe not mean that computation
> is limited.

Which isn't of the same case. You are just showing that you mind can't
tell the fundamental difference.

>
> The thing that trips them up is that some other decider H1 seems to be
> able process the same input that H could not process.

Right, which proves the actual question has an answer. You using the
wrong question is where you go wrong. You have to work with the ACTUAL
question.

You don't seem to understand that you logic is accually the logic to
show that the question in non-computable, not invalid.

>
> They fail to understand that when H1 can provide a Boolean return value
> for the direct execution of D and H cannot that even though they have
> the same input

So, you think the correct result of the exact same question

>
> The question: Does your input halt on its input?
> has a different meaning for H than it does for H1.

Nope, since the input is the input and is a fixed machine that always
does the same thing.

Once you start to ask the question, D has been fixed, as is the H that
it is based on. Thus, the question of "Does this input Halt" has a
definite answer.

>
> If two questions have different meanings then they are not the same
> question.

Right, but "Does the machine represented by this input Halt?" always has
the same meaning if it always represents the same machine.

It doesn't matter who we ask that to.

>
> Can Jack correctly answer “no” to this [yes/no] question?
> is a has a different meaning for Jack than for anyone else.
Red Herring.

>
> Does input D halt on its input?
> has a different meaning for H than for every other decider.
>

Nope. Where does that question refer to H?

Yes, the INPUT has a copy of H in it, but that doesn't lead to the same
contradiction in the problem, just shows that H will be wrong.

Yes, if the Halting Problem question was asking what can H return to be
correct about the halting status of its input, you might get into that
same problem, except that is an illogical question, as the answer a
given program will give to a given input is FIXED by the nature of the
program.

Your question is the same as asking how can 1 + 2 = 4?

You are just showing that you don't understand the nature of programs,
because you are too stupid.

On 10/19/2023 1:26 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.
>
> This exact same reasoning is shown to equally apply to the Peter Linz
> Turing machine based halting problem proof.
>
> *The correct simulation of D by H must include the call from D to H*
> *that specifies that D calls H in recursive simulation*
>
> Consistently all of the reviewers of my work insist that H must ignore
> this recursive simulation and report that D(D) halts because when H does
> not ignore this recursive simulation and aborts its simulation D(D) does
> halt. *They have no idea that their view is inconsistent*
>
> // 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
>

Requiring H to base its halt status decision on behavior that is
different than the behavior that it sees is just like requiring
someone to read the first chapter of War and Peace from the Holy Bible.

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

On 10/19/23 5:47 PM, olcott wrote:
> On 10/19/2023 1:26 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.
>>
>> This exact same reasoning is shown to equally apply to the Peter Linz
>> Turing machine based halting problem proof.
>>
>> *The correct simulation of D by H must include the call from D to H*
>> *that specifies that D calls H in recursive simulation*
>>
>> Consistently all of the reviewers of my work insist that H must ignore
>> this recursive simulation and report that D(D) halts because when H does
>> not ignore this recursive simulation and aborts its simulation D(D) does
>> halt. *They have no idea that their view is inconsistent*
>>
>> // 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
>>
>
> Requiring H to base its halt status decision on behavior that is
> different than the behavior that it sees is just like requiring
> someone to read the first chapter of War and Peace from the Holy Bible.
>

Not on what it "sees", but it is required to base it on the behavior
DEFINED by the question. The decision problem doesn't need to be based
on something "observable" in the input. The Halting Problem is based on
the behavior of the machine represented by the input, not some
potentially partial simulation by the decider.

After all, how is arithmetic "observable?" When we ask a program to find
an approximation to the sin of an angle, it doesn't need to actually
"draw" the angle and measure.

Yes, if the decider can actually directly create an
observable/computable behavior that represents the criteria of the
problem, the making a decider becomes trivial.

The challenge of Halt Deciding, is that non-halting behavior take an
infinte time to actually demonstrate, but the decider need to determine
this in finite time, so it does become a challange. SOME (and only some)
cases have simple methods to detect that the machine is caught in a loop.

Tne fact that there isn't a simple solution makes the problem
interesting, and the problem derives from tough questions that were
trying to be answered about the nature of computations and arithmetic.

The insight into the simple case that shows that this is an uncomputable
problem, became a breakthrough in understanding the limits of our
ability to know about systems. By showing that some things can be
unknowable, we actually are able to learn more about some systems then
we knew before, as we learn to accept partial answers of what we
actually CAN know, and not require finding universal answers that might
not be available.

On 10/19/2023 4:47 PM, olcott wrote:
> On 10/19/2023 1:26 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.
>>
>> This exact same reasoning is shown to equally apply to the Peter Linz
>> Turing machine based halting problem proof.
>>
>> *The correct simulation of D by H must include the call from D to H*
>> *that specifies that D calls H in recursive simulation*
>>
>> Consistently all of the reviewers of my work insist that H must ignore
>> this recursive simulation and report that D(D) halts because when H does
>> not ignore this recursive simulation and aborts its simulation D(D) does
>> halt. *They have no idea that their view is inconsistent*
>>
>> // 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
>>
>
> Requiring H to base its halt status decision on behavior that is
> different than the behavior that it sees is just like requiring
> someone to read the first chapter of War and Peace from the Holy Bible.
>

Requiring the logically impossible merely invalidates the requirement
it places no limitation what-so-ever on the one required.

When H is required to report on the behavior of D that does the opposite
of whatever Boolean value that H returns it is the requirement that is
invalid.

I knew this since 2004. The only thing that has changed is a PhD
computer science professor totally agrees.

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

On 10/19/23 7:53 PM, olcott wrote:
> On 10/19/2023 4:47 PM, olcott wrote:
>> On 10/19/2023 1:26 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.
>>>
>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>> Turing machine based halting problem proof.
>>>
>>> *The correct simulation of D by H must include the call from D to H*
>>> *that specifies that D calls H in recursive simulation*
>>>
>>> Consistently all of the reviewers of my work insist that H must ignore
>>> this recursive simulation and report that D(D) halts because when H does
>>> not ignore this recursive simulation and aborts its simulation D(D) does
>>> halt. *They have no idea that their view is inconsistent*
>>>
>>> // 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
>>>
>>
>> Requiring H to base its halt status decision on behavior that is
>> different than the behavior that it sees is just like requiring
>> someone to read the first chapter of War and Peace from the Holy Bible.
>>
>
> Requiring the logically impossible merely invalidates the requirement
> it places no limitation what-so-ever on the one required.
Yes, YOUR question may be logically impossible, and that shows that
there can't be an actual correct Halt Decider.

The ACTUAL Halting Question is NOT "Logically Impossible", as shown by
H1, and thus is a valid question that H just gets wrong.

>
> When H is required to report on the behavior of D that does the opposite
> of whatever Boolean value that H returns it is the requirement that is
> invalid.

No, H is required to give the answer it is programmed to. To be a
correct Halt Decider that must match the behavior of the program.

Once you talk about "changing" the output of the program, you have
annouced yourself leaving the problem, and showing your stupidity.

You ARGUEMENT is the thing that is "Invalid", because you are arguing
against a Red Herring Strawman.

This shows you don't have an actual arguement.

>
> I knew this since 2004. The only thing that has changed is a PhD
> computer science professor totally agrees.
>

Nope, He doesn't actually agree with your. The statement he agrees with
show, when you use the meaning of the words as he understands them,
shows you are wrong.

And also, that you don't actually understand what you are talking about.

Since you are proving you don't understand what "correct" means, you are
proving you don't understand what "Truth" is/

On 10/19/2023 6:53 PM, olcott wrote:
> On 10/19/2023 4:47 PM, olcott wrote:
>> On 10/19/2023 1:26 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.
>>>
>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>> Turing machine based halting problem proof.
>>>
>>> *The correct simulation of D by H must include the call from D to H*
>>> *that specifies that D calls H in recursive simulation*
>>>
>>> Consistently all of the reviewers of my work insist that H must ignore
>>> this recursive simulation and report that D(D) halts because when H does
>>> not ignore this recursive simulation and aborts its simulation D(D) does
>>> halt. *They have no idea that their view is inconsistent*
>>>
>>> // 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
>>>
>>
>> Requiring H to base its halt status decision on behavior that is
>> different than the behavior that it sees is just like requiring
>> someone to read the first chapter of War and Peace from the Holy Bible.
>>
>
> Requiring the logically impossible merely invalidates the requirement
> it places no limitation what-so-ever on the one required.
>
> When H is required to report on the behavior of D that does the opposite
> of whatever Boolean value that H returns it is the requirement that is
> invalid.
>
> I knew this since 2004. The only thing that has changed is a PhD
> computer science professor totally agrees.
>

He directly reviewed my words and approved them.

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

On 10/19/23 11:53 PM, olcott wrote:
> On 10/19/2023 6:53 PM, olcott wrote:
>> On 10/19/2023 4:47 PM, olcott wrote:
>>> On 10/19/2023 1:26 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.
>>>>
>>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>>> Turing machine based halting problem proof.
>>>>
>>>> *The correct simulation of D by H must include the call from D to H*
>>>> *that specifies that D calls H in recursive simulation*
>>>>
>>>> Consistently all of the reviewers of my work insist that H must ignore
>>>> this recursive simulation and report that D(D) halts because when H
>>>> does
>>>> not ignore this recursive simulation and aborts its simulation D(D)
>>>> does
>>>> halt. *They have no idea that their view is inconsistent*
>>>>
>>>> // 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
>>>>
>>>
>>> Requiring H to base its halt status decision on behavior that is
>>> different than the behavior that it sees is just like requiring
>>> someone to read the first chapter of War and Peace from the Holy Bible.
>>>
>>
>> Requiring the logically impossible merely invalidates the requirement
>> it places no limitation what-so-ever on the one required.
>>
>> When H is required to report on the behavior of D that does the opposite
>> of whatever Boolean value that H returns it is the requirement that is
>> invalid.
>>
>> I knew this since 2004. The only thing that has changed is a PhD
>> computer science professor totally agrees.
>>
>
> He directly reviewed my words and approved them.
>

using the accepted meanng of the words, which means that H must see that
a CORRECT SIMULATION, that is a simulation that would match a UTM, which
would be a simulation that actually never halts, would never stop. This
means that that actually execution of the program represented by the
input would never stop.

Since D(D) when directly run does Halt, as you admit, H never correctly
determined that its simulation would never stop, since it does.

So, you are just shown, AGAIN, to be a LIAR and an IDIOT.

My comment that you are neglecting to quote, because you know it
provides too much evidence that you statement is incorrect is below (and
thus show your bad faith):

>
> Nope, He doesn't actually agree with your. The statement he agrees with show, when you use the meaning of the words as he understands them, shows you are wrong.
>
> And also, that you don't actually understand what you are talking about.
>
> Since you are proving you don't understand what "correct" means, you are proving you don't understand what "Truth" is/

On 10/19/2023 10:53 PM, olcott wrote:
> On 10/19/2023 6:53 PM, olcott wrote:
>> On 10/19/2023 4:47 PM, olcott wrote:
>>> On 10/19/2023 1:26 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.
>>>>
>>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>>> Turing machine based halting problem proof.
>>>>
>>>> *The correct simulation of D by H must include the call from D to H*
>>>> *that specifies that D calls H in recursive simulation*
>>>>
>>>> Consistently all of the reviewers of my work insist that H must ignore
>>>> this recursive simulation and report that D(D) halts because when H
>>>> does
>>>> not ignore this recursive simulation and aborts its simulation D(D)
>>>> does
>>>> halt. *They have no idea that their view is inconsistent*
>>>>
>>>> // 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
>>>>
>>>
>>> Requiring H to base its halt status decision on behavior that is
>>> different than the behavior that it sees is just like requiring
>>> someone to read the first chapter of War and Peace from the Holy Bible.
>>>
>>
>> Requiring the logically impossible merely invalidates the requirement
>> it places no limitation what-so-ever on the one required.
>>
>> When H is required to report on the behavior of D that does the opposite
>> of whatever Boolean value that H returns it is the requirement that is
>> invalid.
>>
>> I knew this since 2004. The only thing that has changed is a PhD
>> computer science professor totally agrees.
>>
>
> He directly reviewed my words and approved them.
>

It is clear that the impossibility of creating a CAD system that can
correctly draw square circles places no limits on what computers can do.

It is less clear that requiring a program H to report on the behavior of
another program D that does the opposite of whatever H says is a logical
impossibility when we see that program H1 can correctly say what D will
do.

When we get back to the original {halting problem} we can see that no
program H can ever always say what every program D will do because some
D will do the opposite of whatever H says.

So the when the {halting problem} requires a program H to always say
whatever program D will do includes programs that do the opposite of
whatever H says this is requiring the logically impossible, thus the
same as requiring a CAD system to correctly draw square circles.

The {halting problem} as defined requires the logically impossible
therefore it places no actual limits on what can be computed.

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

On 10/20/2023 3:30 AM, Richard Damon wrote:

> So, you are just shown, AGAIN, to be a LIAR and an IDIOT.
You are the one misusing words again. Yes, he is most definitely an
IDIOT, no question about it. It's hard to have your head stuck up your
rear end and not be. But a LIAR? No way. You can't lie unless you truly
BELIEVE that a different fact or state is a TRUE one. IDIOTS don't know
the TRUTH even if it hits them in the face.

So quit calling our favorite ignoramus an IDIOT and more directly point
out his lack of intelligence and lack of desire and ability to learn.
Like most fools he is fixated on a fantasy but so are you. Since you
already know that he will approximately repeat himself for all time, why
do you think your repetitious rejoinders raise you above his level. You
surely have something better to do with your life than playing nemesis
to a fool. He doesn't. So people are finding it difficult to distinguish
the two of you.
--
Jeff Barnett

On 10/20/2023 10:13 AM, Jeff Barnett wrote:
> On 10/20/2023 3:30 AM, Richard Damon wrote:
>
>> So, you are just shown, AGAIN, to be a LIAR and an IDIOT.
> You are the one misusing words again. Yes, he is most definitely an
> IDIOT, no question about it. It's hard to have your head stuck up your
> rear end and not be. But a LIAR? No way. You can't lie unless you truly
> BELIEVE that a different fact or state is a TRUE one. IDIOTS don't know
> the TRUTH even if it hits them in the face.
>
> So quit calling our favorite ignoramus an IDIOT and more directly point
^^^^^^
||||||
a LIAR
> out his lack of intelligence and lack of desire and ability to learn.
> Like most fools he is fixated on a fantasy but so are you. Since you
> already know that he will approximately repeat himself for all time, why
> do you think your repetitious rejoinders raise you above his level. You
> surely have something better to do with your life than playing nemesis
> to a fool. He doesn't. So people are finding it difficult to distinguish
> the two of you.

Obvious typo identified above.
--
Jeff Barnett

On 10/20/2023 10:51 AM, olcott wrote:
> On 10/19/2023 10:53 PM, olcott wrote:
>> On 10/19/2023 6:53 PM, olcott wrote:
>>> On 10/19/2023 4:47 PM, olcott wrote:
>>>> On 10/19/2023 1:26 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.
>>>>>
>>>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>>>> Turing machine based halting problem proof.
>>>>>
>>>>> *The correct simulation of D by H must include the call from D to H*
>>>>> *that specifies that D calls H in recursive simulation*
>>>>>
>>>>> Consistently all of the reviewers of my work insist that H must ignore
>>>>> this recursive simulation and report that D(D) halts because when H
>>>>> does
>>>>> not ignore this recursive simulation and aborts its simulation D(D)
>>>>> does
>>>>> halt. *They have no idea that their view is inconsistent*
>>>>>
>>>>> // 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
>>>>>
>>>>
>>>> Requiring H to base its halt status decision on behavior that is
>>>> different than the behavior that it sees is just like requiring
>>>> someone to read the first chapter of War and Peace from the Holy Bible.
>>>>
>>>
>>> Requiring the logically impossible merely invalidates the requirement
>>> it places no limitation what-so-ever on the one required.
>>>
>>> When H is required to report on the behavior of D that does the opposite
>>> of whatever Boolean value that H returns it is the requirement that
>>> is invalid.
>>>
>>> I knew this since 2004. The only thing that has changed is a PhD
>>> computer science professor totally agrees.
>>>
>>
>> He directly reviewed my words and approved them.
>>
>
> It is clear that the impossibility of creating a CAD system that can
> correctly draw square circles places no limits on what computers can do.
>
> It is less clear that requiring a program H to report on the behavior of
> another program D that does the opposite of whatever H says is a logical
> impossibility when we see that program H1 can correctly say what D will
> do.
>
> When we get back to the original {halting problem} we can see that no
> program H can ever always say what every program D will do because some
> D will do the opposite of whatever H says.
>
> So the when the {halting problem} requires a program H to always say
> whatever program D will do includes programs that do the opposite of
> whatever H says this is requiring the logically impossible, thus the
> same as requiring a CAD system to correctly draw square circles.
>
> The {halting problem} as defined requires the logically impossible
> therefore it places no actual limits on what can be computed.
>

Recommending ad hominem attacks instead of sound reasoning
is what Trolls stuck in rebuttal mode always end up saying
or doing.

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

On 10/20/23 11:51 AM, olcott wrote:
> On 10/20/2023 10:51 AM, olcott wrote:
>> On 10/19/2023 10:53 PM, olcott wrote:
>>> On 10/19/2023 6:53 PM, olcott wrote:
>>>> On 10/19/2023 4:47 PM, olcott wrote:
>>>>> On 10/19/2023 1:26 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.
>>>>>>
>>>>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>>>>> Turing machine based halting problem proof.
>>>>>>
>>>>>> *The correct simulation of D by H must include the call from D to H*
>>>>>> *that specifies that D calls H in recursive simulation*
>>>>>>
>>>>>> Consistently all of the reviewers of my work insist that H must
>>>>>> ignore
>>>>>> this recursive simulation and report that D(D) halts because when
>>>>>> H does
>>>>>> not ignore this recursive simulation and aborts its simulation
>>>>>> D(D) does
>>>>>> halt. *They have no idea that their view is inconsistent*
>>>>>>
>>>>>> // 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
>>>>>>
>>>>>
>>>>> Requiring H to base its halt status decision on behavior that is
>>>>> different than the behavior that it sees is just like requiring
>>>>> someone to read the first chapter of War and Peace from the Holy
>>>>> Bible.
>>>>>
>>>>
>>>> Requiring the logically impossible merely invalidates the requirement
>>>> it places no limitation what-so-ever on the one required.
>>>>
>>>> When H is required to report on the behavior of D that does the
>>>> opposite
>>>> of whatever Boolean value that H returns it is the requirement that
>>>> is invalid.
>>>>
>>>> I knew this since 2004. The only thing that has changed is a PhD
>>>> computer science professor totally agrees.
>>>>
>>>
>>> He directly reviewed my words and approved them.
>>>
>>
>> It is clear that the impossibility of creating a CAD system that can
>> correctly draw square circles places no limits on what computers can do.
>>
>> It is less clear that requiring a program H to report on the behavior of
>> another program D that does the opposite of whatever H says is a logical
>> impossibility when we see that program H1 can correctly say what D will
>> do.
>>
>> When we get back to the original {halting problem} we can see that no
>> program H can ever always say what every program D will do because some
>> D will do the opposite of whatever H says.
>>
>> So the when the {halting problem} requires a program H to always say
>> whatever program D will do includes programs that do the opposite of
>> whatever H says this is requiring the logically impossible, thus the
>> same as requiring a CAD system to correctly draw square circles.
>>
>> The {halting problem} as defined requires the logically impossible
>> therefore it places no actual limits on what can be computed.
>>
>
> Recommending ad hominem attacks instead of sound reasoning
> is what Trolls stuck in rebuttal mode always end up saying
> or doing.
>

So, you also don't know what an ad hominem arguement is. An "ad hominem"
attacks is one where a person asserts that in arguement is "invalid"
because of some attribute of the person making the statement.

I haven't do that.

I have pointed out the errors in your logic, and point out that the fact
that you repeatedly make the same error, despite it being pointed out,
shows that you have a characteristic.

That is NOT an "ad hominem" attack.

On 10/20/23 8:51 AM, olcott wrote:
> On 10/19/2023 10:53 PM, olcott wrote:
>> On 10/19/2023 6:53 PM, olcott wrote:
>>> On 10/19/2023 4:47 PM, olcott wrote:
>>>> On 10/19/2023 1:26 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.
>>>>>
>>>>> This exact same reasoning is shown to equally apply to the Peter Linz
>>>>> Turing machine based halting problem proof.
>>>>>
>>>>> *The correct simulation of D by H must include the call from D to H*
>>>>> *that specifies that D calls H in recursive simulation*
>>>>>
>>>>> Consistently all of the reviewers of my work insist that H must ignore
>>>>> this recursive simulation and report that D(D) halts because when H
>>>>> does
>>>>> not ignore this recursive simulation and aborts its simulation D(D)
>>>>> does
>>>>> halt. *They have no idea that their view is inconsistent*
>>>>>
>>>>> // 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
>>>>>
>>>>
>>>> Requiring H to base its halt status decision on behavior that is
>>>> different than the behavior that it sees is just like requiring
>>>> someone to read the first chapter of War and Peace from the Holy Bible.
>>>>
>>>
>>> Requiring the logically impossible merely invalidates the requirement
>>> it places no limitation what-so-ever on the one required.
>>>
>>> When H is required to report on the behavior of D that does the opposite
>>> of whatever Boolean value that H returns it is the requirement that
>>> is invalid.
>>>
>>> I knew this since 2004. The only thing that has changed is a PhD
>>> computer science professor totally agrees.
>>>
>>
>> He directly reviewed my words and approved them.
>>
>
> It is clear that the impossibility of creating a CAD system that can
> correctly draw square circles places no limits on what computers can do.
>
> It is less clear that requiring a program H to report on the behavior of
> another program D that does the opposite of whatever H says is a logical
> impossibility when we see that program H1 can correctly say what D will
> do.
>
> When we get back to the original {halting problem} we can see that no
> program H can ever always say what every program D will do because some
> D will do the opposite of whatever H says.

Which doesn't make that Halting Question fundamentally a logical
impossibility (as shown that H1 gave the right answer),

>
> So the when the {halting problem} requires a program H to always say
> whatever program D will do includes programs that do the opposite of
> whatever H says this is requiring the logically impossible, thus the
> same as requiring a CAD system to correctly draw square circles.
>

No, the Halting Problem requires that a program H to always give the
right answer about if the program represented by the input Halt.

Since there always IS a right answer, the problem is logical.

That we can't actually build such a program, says the problem is
non-computable.

You sem to not know the difference.

> The {halting problem} as defined requires the logically impossible
> therefore it places no actual limits on what can be computed.
>

Nope. You are just working with a Red Herring.

Since the ACTUAL Halting Problem question has a correct answer for every
input, the question is NOT "illogical".

And you are showing you don't know what that actually means.

On 10/20/23 9:13 AM, Jeff Barnett wrote:
> On 10/20/2023 3:30 AM, Richard Damon wrote:
>
>> So, you are just shown, AGAIN, to be a LIAR and an IDIOT.
> You are the one misusing words again. Yes, he is most definitely an
> IDIOT, no question about it. It's hard to have your head stuck up your
> rear end and not be. But a LIAR? No way. You can't lie unless you truly
> BELIEVE that a different fact or state is a TRUE one. IDIOTS don't know
> the TRUTH even if it hits them in the face.
>
> So quit calling our favorite ignoramus an IDIOT and more directly point
> out his lack of intelligence and lack of desire and ability to learn.
> Like most fools he is fixated on a fantasy but so are you. Since you
> already know that he will approximately repeat himself for all time, why
> do you think your repetitious rejoinders raise you above his level. You
> surely have something better to do with your life than playing nemesis
> to a fool. He doesn't. So people are finding it difficult to distinguish
> the two of you.

Actually, Lies do NOT need to done knowingly. That is just ONE of the
definition. Others include other false statements, especially if the
falsehood should be clear.

For example, from Merriam-Webster at:

https://www.merriam-webster.com/dictionary/lie?src=search-dict-box

1 a: an assertion of something known or believed by the speaker or
writer to be untrue with intent to deceive He told a lie to avoid
punishment.
b: an untrue or inaccurate statement that may or may not be believed
true by the speaker or writer
the lies we tell ourselves to feel better
historical records containing numerous lies

2: something that misleads or deceives
His show of remorse was a lie.
3: a charge of lying (see LIE entry 3)

Note 1b specifically doesn't require knowledge of the falsehood, and 2
just refers to the fact the statement misleads (even if beleived true).