XPost: sci.logic

On 2/3/24 2:13 PM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must
abort its simulation of D to prevent its own non-termination.

So it is a corrrect POOP decider.

Since for every H(D,D) that returns 0, D(D) will Halt

IT CAN'T be a "Correct" Halt Decider by the DEFINITIONS.

*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

And you paper just shows that any H that answers does not "correctly" simulation it inputs per the definition of a UTM.

You arte just proving that you are a pathological liar, and an idiot.

Your errors have been explained, an accepted since not refuted, and you
are showing your utter inability to learn or apply correct logic, likely because you have "brainwashed" yourself with your own lies.

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

XPost: sci.logic

On 2/3/24 3:38 PM, olcott wrote:

On 2/3/2024 2:28 PM, Richard Damon wrote:

On 2/3/24 2:13 PM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must
abort its simulation of D to prevent its own non-termination.

So it is a corrrect POOP decider.

Since for every H(D,D) that returns 0, D(D) will Halt

IT CAN'T be a "Correct" Halt Decider by the DEFINITIONS.

*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

And you paper just shows that any H that answers does not "correctly"
simulation it inputs per the definition of a UTM.

D correctly simulated by H cannot possibly reach its simulated final
state in 1 to ∞ steps of correct simulation.

And H that actually correctly simulates its input will not answer.

Since the only D that matters (or really exists in the proof), is the D
built on the decider that is claimed to be correct. Since if H aborts
its simulation, it did NOT do a "Correct Simulation" per the definition required by your statement.

And thus, the CORRECT SIMULATION of the D that was given to your H will
call that same H and it will return that same answer, and thus halt.

Remember, the one and only criteria for something called a Halt Decider,
in the field of Computation Theory, which you are invoking by your
references, is does the PROGRAM represented by the input Halt When it is
run.

Since your input doesn't contain the normally required copy of H, that
means you must have stipuated a specific implementation for H, and we
can't look at anything else (or you are just admitting to lying about
working on the halting problem).

You arte just proving that you are a pathological liar, and an idiot.

That is libelous.

Nope, it is a TRUE statement so not libelous,

You willing to try to testify UNDER OATH that your statements are true,


Remember, your thoughts on the truth of the statement do not apply to PATHOLOGICAL lying, as that is based on your shown inability to
understand what is actually true.

and argue against expeert witnesses?

Your errors have been explained, an accepted since not refuted, and
you are showing your utter inability to learn or apply correct logic,
likely because you have "brainwashed" yourself with your own lies.

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

XPost: sci.logic

On 2/3/24 4:52 PM, olcott wrote:

On 2/3/2024 3:12 PM, Richard Damon wrote:

On 2/3/24 3:38 PM, olcott wrote:

On 2/3/2024 2:28 PM, Richard Damon wrote:

On 2/3/24 2:13 PM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must
abort its simulation of D to prevent its own non-termination.

So it is a corrrect POOP decider.

Since for every H(D,D) that returns 0, D(D) will Halt

IT CAN'T be a "Correct" Halt Decider by the DEFINITIONS.

*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

And you paper just shows that any H that answers does not
"correctly" simulation it inputs per the definition of a UTM.

D correctly simulated by H cannot possibly reach its simulated final
state in 1 to ∞ steps of correct simulation.

And H that actually correctly simulates its input will not answer.

The following only requires N steps of correct simulation.
Your ADD prevents you from paying enough attention to see this.

simulates its input D until ...
simulates its input D until ...
simulates its input D until ...

Except once H aborts its simulation, the CORRECT simulation of the
input, which uses that EXACT SAME H AS ABORTED, will continue past the
point that H aborted, sees its simulted first simulated H abort its
simulation and return to the first simulated D and it Halting.


H didn't correctly simulate its input, so any criteria based on "A
correct simulation by H" is VOIDED by H not meeting the requirement to
DO an actual correct simulation.

The ACTUAL definition of what H needs to do is predict the behavior of
the computation described by its input, which if you are doing the proof calculation is the D built on the specific H that is giving the answer,
and thus the H that aborted it simulation.

On 10/13/2022 11:46 AM, olcott wrote:

MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...

If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.

Right, and it did not CORRECTLY determine that its CORRCT simulation
would not halt, since it doesn't do a correct simulation.

It also didn't CORRECTLY determine the THE CORRECT simulation would not
halt, since we show it does.

Your failure to understand this just shows your utter IGNORANCE of what
you are talking about.

H can't use logic about some other D based on some other H, but MUST use
the input given to it, which is a PROGRAM with defined behavior, which
is to call the one and only H which is being claimed gets the right answer.

You are just proving that you are just an ignorant Pathological Lyin g
idiot.

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

XPost: sci.logic

On 2/3/24 6:14 PM, olcott wrote:

On 2/3/2024 4:16 PM, Richard Damon wrote:

On 2/3/24 4:52 PM, olcott wrote:

On 2/3/2024 3:12 PM, Richard Damon wrote:

On 2/3/24 3:38 PM, olcott wrote:

On 2/3/2024 2:28 PM, Richard Damon wrote:

On 2/3/24 2:13 PM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must
abort its simulation of D to prevent its own non-termination.

So it is a corrrect POOP decider.

Since for every H(D,D) that returns 0, D(D) will Halt

IT CAN'T be a "Correct" Halt Decider by the DEFINITIONS.

*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

And you paper just shows that any H that answers does not
"correctly" simulation it inputs per the definition of a UTM.

D correctly simulated by H cannot possibly reach its simulated
final state in 1 to ∞ steps of correct simulation.

And H that actually correctly simulates its input will not answer.

The following only requires N steps of correct simulation.
Your ADD prevents you from paying enough attention to see this.

simulates its input D until ...
simulates its input D until ...
simulates its input D until ...

Except once H aborts its simulation, the CORRECT simulation of the
input, which uses that EXACT SAME H AS ABORTED, will continue past the
point that H aborted, sees its simulted first simulated H abort its
simulation and return to the first simulated D and it Halting.


H didn't correctly simulate its input, so any criteria based on "A
correct simulation by H" is VOIDED by H not meeting the requirement to
DO an actual correct simulation.

The ACTUAL definition of what H needs to do is predict the behavior of
the computation described by its input, which if you are doing the
proof calculation is the D built on the specific H that is giving the
answer, and thus the H that aborted it simulation.

On 10/13/2022 11:46 AM, olcott wrote:

MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...
;
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.
;

Right, and it did not CORRECTLY determine that its CORRCT simulation
would not halt, since it doesn't do a correct simulation.

That you are unable to comprehend that N steps of correct simulation correctly simulates these N steps is merely yet another instance of
your denial of self-evident truths.

I have not said that H doesn't PARTIALLY simulate the first N steps of
the behavior of the input.

That is NOT a "Correct Simulation" by the definition of a UTM, and
doesn't show non-halting behavior. Since you are using the definition of
a UTM to replace the behavior of the program described by the input,
with a simulation, you need to use the UTMs definition of Simulation,
which is a non-aborted simulation.

Thus, it is YOU who denies the "self-evident truth".

You are also horrendously terrible at understanding that when every
element of a set has a property that this semantically entails
that each element of this same set has this property.

But every element of the set DOESN'T have that property.

Every element that aborts its simulation, fails to meed the requirement
to correctly simulate the input.

Since every case needs to be considered separately (as the question is
about specific inputs, and that case in question that input has been
paired with a specific decider for the proof case, that you are trying
to refute) we can look at each specific case.

If H does abort its simulation (and thus H doesn't do a correct
simulation to make claims about), then D is built on that H that aborts
its simulation, and the only criteria we have left are the direct
execution and the actual correct simulation of that D, which calls THIS
H (that aborts) then that H will simulate the "N steps" and abort and
return non-halting to D and D will Halt.

You have agreed to this behavior (by default) as you have failed to show
where that H called by the directly executed or correctly simulated D
actually differs from the behavior of the direct running of H(D,D).

Thus, the only correct answer is Halting, which isn't what H predicted,
thus your claims are shown to just be LIES.

When zero elements of every H that simulates D can ever stop
running unless they abort their simulation of D then this
entails D species non-halting behavior.

But, the only elements of the set that DO "Correctly Simulate" there
inputs, are the ones that don't abort, and those don't answer.

For every element of the set that DOES abort, the ACTUAL CORRECT
simulation halts.

Thus, the condition that ZERO element satisfies is giving the actual
correct answer about the actual correct simulation of the input.

It is like you are disagreeing that cats are cats because
you firmly believe that cats are dogs, never comprehending
that disagreeing with a tautology is always necessarily incorrect.

Just shows your reliance on Red Herring, because you (should) KNOW that
your logic is flawed (or you are just too stupid to learn).

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

XPost: sci.logic

On 2/3/24 7:36 PM, olcott wrote:

On 2/3/2024 6:20 PM, Richard Damon wrote:

On 2/3/24 6:14 PM, olcott wrote:

On 2/3/2024 4:16 PM, Richard Damon wrote:

On 2/3/24 4:52 PM, olcott wrote:

On 2/3/2024 3:12 PM, Richard Damon wrote:

On 2/3/24 3:38 PM, olcott wrote:

On 2/3/2024 2:28 PM, Richard Damon wrote:

On 2/3/24 2:13 PM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must >>>>>>>>> abort its simulation of D to prevent its own non-termination. >>>>>>>>

So it is a corrrect POOP decider.

Since for every H(D,D) that returns 0, D(D) will Halt

IT CAN'T be a "Correct" Halt Decider by the DEFINITIONS.

*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

And you paper just shows that any H that answers does not
"correctly" simulation it inputs per the definition of a UTM.

D correctly simulated by H cannot possibly reach its simulated
final state in 1 to ∞ steps of correct simulation.

And H that actually correctly simulates its input will not answer. >>>>>>

The following only requires N steps of correct simulation.
Your ADD prevents you from paying enough attention to see this.

simulates its input D until ...
simulates its input D until ...
simulates its input D until ...

Except once H aborts its simulation, the CORRECT simulation of the
input, which uses that EXACT SAME H AS ABORTED, will continue past
the point that H aborted, sees its simulted first simulated H abort
its simulation and return to the first simulated D and it Halting.


H didn't correctly simulate its input, so any criteria based on "A
correct simulation by H" is VOIDED by H not meeting the requirement
to DO an actual correct simulation.

The ACTUAL definition of what H needs to do is predict the behavior
of the computation described by its input, which if you are doing
the proof calculation is the D built on the specific H that is
giving the answer, and thus the H that aborted it simulation.

On 10/13/2022 11:46 AM, olcott wrote:

MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...
;
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.
;

Right, and it did not CORRECTLY determine that its CORRCT simulation
would not halt, since it doesn't do a correct simulation.

That you are unable to comprehend that N steps of correct simulation
correctly simulates these N steps is merely yet another instance of
your denial of self-evident truths.

I have not said that H doesn't PARTIALLY simulate the first N steps of
the behavior of the input.

That is NOT a "Correct Simulation" by the definition of a UTM, and

In other words a correct simulation of N states is an incorrect
simulation of N states.

No, it is just not a "Correct Simulation" for the purposes of
determining Halting, it is just a Correct Partial Simulation.

It shows Hasn't Halted so far, not that it will never halt.

If you look at the first N inches of a piece of string, and didn't find
the end, can you tell how long the string is?

You don't seem to understand what words mean.

I think your semantic processor is broken.

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

XPost: sci.logic

On 2/3/24 9:38 PM, olcott wrote:

On 2/3/2024 6:48 PM, Richard Damon wrote:

On 2/3/24 7:36 PM, olcott wrote:

On 2/3/2024 6:20 PM, Richard Damon wrote:

On 2/3/24 6:14 PM, olcott wrote:

On 2/3/2024 4:16 PM, Richard Damon wrote:

On 2/3/24 4:52 PM, olcott wrote:

On 2/3/2024 3:12 PM, Richard Damon wrote:

On 2/3/24 3:38 PM, olcott wrote:

On 2/3/2024 2:28 PM, Richard Damon wrote:

On 2/3/24 2:13 PM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must >>>>>>>>>>> abort its simulation of D to prevent its own non-termination. >>>>>>>>>>

So it is a corrrect POOP decider.

Since for every H(D,D) that returns 0, D(D) will Halt

IT CAN'T be a "Correct" Halt Decider by the DEFINITIONS.

*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

And you paper just shows that any H that answers does not
"correctly" simulation it inputs per the definition of a UTM. >>>>>>>>>>

D correctly simulated by H cannot possibly reach its simulated >>>>>>>>> final state in 1 to ∞ steps of correct simulation.

And H that actually correctly simulates its input will not answer. >>>>>>>>

The following only requires N steps of correct simulation.
Your ADD prevents you from paying enough attention to see this.

simulates its input D until ...
simulates its input D until ...
simulates its input D until ...

Except once H aborts its simulation, the CORRECT simulation of the >>>>>> input, which uses that EXACT SAME H AS ABORTED, will continue past >>>>>> the point that H aborted, sees its simulted first simulated H
abort its simulation and return to the first simulated D and it
Halting.


H didn't correctly simulate its input, so any criteria based on "A >>>>>> correct simulation by H" is VOIDED by H not meeting the
requirement to DO an actual correct simulation.

The ACTUAL definition of what H needs to do is predict the
behavior of the computation described by its input, which if you
are doing the proof calculation is the D built on the specific H
that is giving the answer, and thus the H that aborted it simulation. >>>>>>

On 10/13/2022 11:46 AM, olcott wrote:

MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...
;
If simulating halt decider H correctly simulates its input D >>>>>>>  > until H correctly determines that its simulated D would never >>>>>>>  > stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.
;

Right, and it did not CORRECTLY determine that its CORRCT
simulation would not halt, since it doesn't do a correct simulation. >>>>>

That you are unable to comprehend that N steps of correct simulation >>>>> correctly simulates these N steps is merely yet another instance of
your denial of self-evident truths.

I have not said that H doesn't PARTIALLY simulate the first N steps
of the behavior of the input.

That is NOT a "Correct Simulation" by the definition of a UTM, and

In other words a correct simulation of N states is an incorrect
simulation of N states.

No, it is just not a "Correct Simulation" for the purposes of
determining Halting, it is just a Correct Partial Simulation.

It shows Hasn't Halted so far, not that it will never halt.

Your ADD continues to totally screw you up.

*Read this 500 times if you need to*
H correctly simulates its input D until H correctly determines that its simulated D would never stop running unless aborted then H can abort its simulation.

Then you H MUST continue simulating forever, because if it does think it
has correctly determined this, and aborts and return 0, that makes the
D(D) that calls this H(D,D) Halt, and thus H could NOT have been
"Correct" in determining something to happend that does not happen.

Your logic just assumes that you can detect a condition that just
doesn't exist.

*Correct Halt Status Criteria*
That H sees that D is calling itself with its same parameters may
by itself prove that D specifies non-halting behavior.

INCORRECT.

Since if H uses that H(D,D) says non-halting when that same D(D) Halts.

That violate the DEFINITION of a Halt Decider, which must accept the
input if the Computation described halts when run.

Since H(D,D) return 0, the D(D) built on that H will Halt, thus the ONLY CORRECT answer that H should have returned was Halting (1).

Your logic presumes H to be non-aborting, when it does abort.

*Since D is a pure function* (as required by the theory of computation)

If there were any conditional branch instructions in D prior to
this call it is already proved that they didn't make any difference.

Nope, because the "loop" includes H, so H must not be conditional for
that criteria to work.

PROVEN and accepted by you by your failure to show how that doesn't happen.

https://en.wikipedia.org/wiki/Pure_function

Yes, as H must be, so if H(D,D) returns 0 when called, it also return 0
to D(D) when it make the same call, and thus D(D) will halt.

PROVEN and accepted by you by failure to show the step where that
doesn't happen.

So, you are just proving that you are totally not understanding how
logic works and are just using invalid, and unsound logic, fueled by
incorrect definitions because you made yourself INTENTIONALLY ignorant
of the subject.

That just makes you an ignorant hypocritical pathologically lying idiot.

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

XPost: sci.logic

On 3/02/24 20:13, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }

It is self-evident that every H that correctly simulates D must
abort its simulation of D to prevent its own non-termination.

That's right! There are three possible ways to write H:

1. Hss that does not halt.
2. Han that halts and returns 0 which is the wrong answer for Dan
because Dan halts.
3. Hah that halts and returns 1 which is the wrong answer for Dah
because Dah does not halt.

You wrote Han. It halts and returns 0, which is the wrong answer for Dan because Dan halts.

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

XPost: sci.logic

On 3/02/24 22:52, olcott wrote:

The following only requires N steps of correct simulation.
Your ADD prevents you from paying enough attention to see this.

simulates its input D until ...
simulates its input D until ...
simulates its input D until ...

You have written a simulator which simulates the program for N steps,
paired with a program which executes for N+k steps and halts (k is
greater than 0). No matter what number you choose to be N, the program
will always halt, and the simulator will never simulate all the way to
the end.

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

XPost: sci.logic

On 4/02/24 00:14, olcott wrote:

On 2/3/2024 4:16 PM, Richard Damon wrote:

On 2/3/24 4:52 PM, olcott wrote:

Right, and it did not CORRECTLY determine that its CORRCT simulation
would not halt, since it doesn't do a correct simulation.

That you are unable to comprehend that N steps of correct simulation correctly simulates these N steps is merely yet another instance of
your denial of self-evident truths.

That you are unable to comprehend that N steps of correct simulation do
not correctly simulate N+1 steps is merely yet another instance of your
denial of self-evident truths.

When zero elements of every H that simulates D

This is nonsensical. H is not a set.

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