XPost: sci.logic

On 3/20/24 11:47 PM, olcott wrote:

On 3/20/2024 9:41 PM, Richard Damon wrote:

On 3/20/24 10:18 PM, olcott wrote:

On 3/20/2024 9:13 PM, Richard Damon wrote:

On 3/20/24 7:38 PM, olcott wrote:

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

On 3/20/24 6:52 PM, olcott wrote:

On 3/20/2024 5:47 PM, immibis wrote:

On 20/03/24 23:01, olcott wrote:

On 3/20/2024 4:51 PM, Richard Damon wrote:

On 3/20/24 3:07 PM, olcott wrote:

On 3/20/2024 1:49 PM, Fred. Zwarts wrote:

Op 20.mrt.2024 om 17:11 schreef olcott:

On 3/20/2024 10:50 AM, Mikko wrote:

On 2024-03-20 13:20:51 +0000, olcott said:

On 3/20/2024 3:24 AM, Mikko wrote:

On 2024-03-19 18:15:42 +0000, olcott said:

On 3/19/2024 12:41 PM, immibis wrote:

On 19/03/24 05:11, olcott wrote:

On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:

On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:

On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must >>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>

*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>

Strawman deception. H is a halt decider if it >>>>>>>>>>>>>>>>>>>>>>>>>> tells whether the direct execution of its >>>>>>>>>>>>>>>>>>>>>>>>>> input would halt.

If you can't even understand that H is a >>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
you can't understand anything else that >>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>

Strawman deception. It is the halting problem, >>>>>>>>>>>>>>>>>>>>>>>> not the Olcott abort problem.

You can learn calculus without the basis of >>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
simulating halt deciders without the basis of >>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.

When are you going to extend this theory of >>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the >>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the >>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?

*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer >>>>>>>>>>>>>>>>>>>>> to an incorrect question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>

But (2) is a LIE.

There is nothing "Incorrect" about the Halting >>>>>>>>>>>>>>>>>>>> Question.

Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second >>>>>>>>>>>>>>>>>>> entity.

If Ĥ is your x86utm function D, then "yes" is the >>>>>>>>>>>>>>>>>> correct answer to all entities.

*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>

What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>

D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
<are>
correctly reporting on what they actually see.

Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>

*That would cause D(D) to loop, thus wrong answer*

No. The H that answers 'yes' is a different H.

Can D correctly simulated by H terminate normally?
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 }

Every H(D,D) that does not abort its simulation input never >>>>>>>>>>> stops running.

It would be correct for this D. We can build another D, >>>>>>>>>>>> based on the new H, but then the question changes, because >>>>>>>>>>>> the input changes. The new H does not give the correct >>>>>>>>>>>> answer for the new D.

*That would cause D(D) to loop, thus wrong answer*

No. The H that answers 'yes' is a different H. It would be >>>>>>>>>>>> correct for this D. We can build another D, based on the new >>>>>>>>>>>> H, but then the question changes, because the input changes. >>>>>>>>>>>> The new H does not give the correct answer for the new D. >>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
No. The H that answers 'yes' is a different H. It would be >>>>>>>>>>>> correct for this D. We can build another D, based on the new >>>>>>>>>>>> H, but then the question changes, because the input changes. >>>>>>>>>>>> The new H does not give the correct answer for the new D. >>>>>>>>>>>>
Both questions have a correct answer, but the corresponding >>>>>>>>>>>> H failed to give it. It seems Olcott is again confused, >>>>>>>>>>>> because he uses the same names for different things.

Every H(D,D) that does not abort its simulation input never >>>>>>>>>>> stops running.

Trying to refer to a different H than every H is a very lame >>>>>>>>>>> attempt to get away with the strawman deception.

Referring to a different D then the one you were given is a >>>>>>>>>> very lame attempt to get away with a strawman deception.

I am specifying a single D and an infinite set of
implementations of H.

If you are still talking about the Linz proof instead of some
bullshit, every D is based on exactly one H. If you change H but >>>>>>>> don't change D, the D is still based on the old H and the
correct answer to the question "Does D(D) halt?" does not change. >>>>>>>>

Can D correctly simulated by H terminate normally?
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 }

If you want to construe this as an infinite set of H/D pairs
where you
are construing that each D is somehow different this makes no
difference
at all.

Every H(D,D) that doesn't abort its simulated input never stops
running.
Every H(D,D) that doesn't abort its simulated input never stops
running.
Every H(D,D) that doesn't abort its simulated input never stops
running.

Which STILL doesn't say what happens to the D's built on the Hs
that DO Abort.

*All of them are on the correct side of the abort/no abort decision*

Then why do they get the wrong answer?

Are you trying to get away with contradicting yourself?

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

On 3/20/24 6:01 PM, olcott wrote:

Every H(D,D) that doesn't abort its simulated input
never stops running.

;
Yep, shows that H's that don't abort the D built on
them won't be deciders...

Nothing contradictory about that.

You have two distinct classes of H, that make DIFFERENT errors due to
different behaviors they create.

Those whose programming make them never abort create a D that will
never halt, because its H get stuck in an infinite simulation loop,
the the top level H also gets stuck in. It NEEDS to abort, but doesn't

Then you have those H whose programming makes themselves abort, that
create a D that calls an H that also aborts its simulation

Finally the right insertion point for these words. V3
So you don't understand that when the executed H does not abort that
none of them do because they are all the exact same code?

IF H is defined to not abort its simulation, then H will fail to be a
decider.

Since the input changes behavior when H changes, something you don't
seem to understand, this meas that the fact that a D built on a
non-aborting H is non-halting doesn't tell you anything about a D that
uses an aborting H.

This fact seem to be beyond nd your ability to uderstand.

and returns causse that D to Halt. Thus this H, will it aborts its
simulation, didn't NEED to abort it.

So, the nature of the problem cause the need to be opposite the
actions of H, so all Hs are on the wrong side of the line.

You could argue that your version of the problem, with its ACTUAL
Pathological actual reference to the decider deciding it is truly an
invalid problem as no decider can possible get the right answer.

But then, this problem isn't a Turing Equivalent to anything that
could be constructed with Turing machine(s), due to its jumbled up
input and decider.

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

XPost: sci.logic

On 3/21/24 10:27 AM, olcott wrote:

On 3/21/2024 6:37 AM, Richard Damon wrote:

On 3/20/24 11:47 PM, olcott wrote:

On 3/20/2024 9:41 PM, Richard Damon wrote:

On 3/20/24 10:18 PM, olcott wrote:

On 3/20/2024 9:13 PM, Richard Damon wrote:

On 3/20/24 7:38 PM, olcott wrote:

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

On 3/20/24 6:52 PM, olcott wrote:

On 3/20/2024 5:47 PM, immibis wrote:

On 20/03/24 23:01, olcott wrote:

On 3/20/2024 4:51 PM, Richard Damon wrote:

On 3/20/24 3:07 PM, olcott wrote:

On 3/20/2024 1:49 PM, Fred. Zwarts wrote:

Op 20.mrt.2024 om 17:11 schreef olcott:

On 3/20/2024 10:50 AM, Mikko wrote:

On 2024-03-20 13:20:51 +0000, olcott said:

On 3/20/2024 3:24 AM, Mikko wrote:

On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>

On 3/19/2024 12:41 PM, immibis wrote:

On 19/03/24 05:11, olcott wrote:

On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>

Strawman deception. H is a halt decider if >>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt.

If you can't even understand that H is a >>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then >>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that >>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite >>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>

Strawman deception. It is the halting problem, >>>>>>>>>>>>>>>>>>>>>>>>>> not the Olcott abort problem. >>>>>>>>>>>>>>>>>>>>>>>>>

You can learn calculus without the basis of >>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
simulating halt deciders without the basis of >>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.

When are you going to extend this theory of >>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the >>>>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the >>>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?

*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct >>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be >>>>>>>>>>>>>>>>>>>>>>> redefined.

But (2) is a LIE.

There is nothing "Incorrect" about the Halting >>>>>>>>>>>>>>>>>>>>>> Question.

Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second >>>>>>>>>>>>>>>>>>>>> entity.

If Ĥ is your x86utm function D, then "yes" is the >>>>>>>>>>>>>>>>>>>> correct answer to all entities.

*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>

What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>

D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
<are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>

Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>

*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.

Can D correctly simulated by H terminate normally?
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 }

Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>> stops running.

It would be correct for this D. We can build another D, >>>>>>>>>>>>>> based on the new H, but then the question changes, because >>>>>>>>>>>>>> the input changes. The new H does not give the correct >>>>>>>>>>>>>> answer for the new D.

*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be >>>>>>>>>>>>>> correct for this D. We can build another D, based on the >>>>>>>>>>>>>> new H, but then the question changes, because the input >>>>>>>>>>>>>> changes. The new H does not give the correct answer for >>>>>>>>>>>>>> the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be >>>>>>>>>>>>>> correct for this D. We can build another D, based on the >>>>>>>>>>>>>> new H, but then the question changes, because the input >>>>>>>>>>>>>> changes. The new H does not give the correct answer for >>>>>>>>>>>>>> the new D.

Both questions have a correct answer, but the
corresponding H failed to give it. It seems Olcott is >>>>>>>>>>>>>> again confused, because he uses the same names for >>>>>>>>>>>>>> different things.

Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>> stops running.

Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>> attempt to get away with the strawman deception.

Referring to a different D then the one you were given is a >>>>>>>>>>>> very lame attempt to get away with a strawman deception. >>>>>>>>>>>

I am specifying a single D and an infinite set of
implementations of H.

If you are still talking about the Linz proof instead of some >>>>>>>>>> bullshit, every D is based on exactly one H. If you change H >>>>>>>>>> but don't change D, the D is still based on the old H and the >>>>>>>>>> correct answer to the question "Does D(D) halt?" does not change. >>>>>>>>>>

Can D correctly simulated by H terminate normally?
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 }

If you want to construe this as an infinite set of H/D pairs >>>>>>>>> where you
are construing that each D is somehow different this makes no >>>>>>>>> difference
at all.

Every H(D,D) that doesn't abort its simulated input never stops >>>>>>>>> running.
Every H(D,D) that doesn't abort its simulated input never stops >>>>>>>>> running.
Every H(D,D) that doesn't abort its simulated input never stops >>>>>>>>> running.

Which STILL doesn't say what happens to the D's built on the Hs >>>>>>>> that DO Abort.

*All of them are on the correct side of the abort/no abort decision* >>>>>>

Then why do they get the wrong answer?

Are you trying to get away with contradicting yourself?

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

On 3/20/24 6:01 PM, olcott wrote:

Every H(D,D) that doesn't abort its simulated input
never stops running.

;
Yep, shows that H's that don't abort the D built on
them won't be deciders...

Nothing contradictory about that.

You have two distinct classes of H, that make DIFFERENT errors due
to different behaviors they create.

Those whose programming make them never abort create a D that will
never halt, because its H get stuck in an infinite simulation loop,
the the top level H also gets stuck in. It NEEDS to abort, but doesn't >>>>
Then you have those H whose programming makes themselves abort, that
create a D that calls an H that also aborts its simulation

Finally the right insertion point for these words. V3
So you don't understand that when the executed H does not abort that
none of them do because they are all the exact same code?

IF H is defined to not abort its simulation, then H will fail to be a
decider.

that create a D that calls an H that also aborts its simulation <<<

No this is incorrect.

Unless the outermost H(D,D) aborts its simulation none of them
ever abort their simulation because they are all the exact same
machine-code.

Right, and that H fails to be a decider.

But if H does abort it simulation, then the fact that the other
instances do too, mean that this one didn't need to.

Your definion makes H affect its input, and it can't call the input
non-halting or needing to be aborted since that input WILL halt and
doesn't need to be aborted. It IS what it IS.

Just as H is what it is, the input is what it is, and that will just
always make H wrong.

It is INVALID to try to talk about an input that isn't the actual input
given.

After all, WHICH of the infinite other inputs is a better replacement?

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

XPost: sci.logic

On 22/03/24 05:27, olcott wrote:

On 3/21/2024 10:10 PM, Richard Damon wrote:

On 3/21/24 10:27 AM, olcott wrote:

On 3/21/2024 6:37 AM, Richard Damon wrote:

On 3/20/24 11:47 PM, olcott wrote:

On 3/20/2024 9:41 PM, Richard Damon wrote:

On 3/20/24 10:18 PM, olcott wrote:

On 3/20/2024 9:13 PM, Richard Damon wrote:

On 3/20/24 7:38 PM, olcott wrote:

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

On 3/20/24 6:52 PM, olcott wrote:

On 3/20/2024 5:47 PM, immibis wrote:

On 20/03/24 23:01, olcott wrote:

On 3/20/2024 4:51 PM, Richard Damon wrote:

On 3/20/24 3:07 PM, olcott wrote:

On 3/20/2024 1:49 PM, Fred. Zwarts wrote:

Op 20.mrt.2024 om 17:11 schreef olcott:

On 3/20/2024 10:50 AM, Mikko wrote:

On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>

On 3/20/2024 3:24 AM, Mikko wrote:

On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>

On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:

On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Strawman deception. H is a halt decider if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If you can't even understand that H is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then >>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite >>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Strawman deception. It is the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, not the Olcott abort problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>

You can learn calculus without the basis of >>>>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn >>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of >>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders. >>>>>>>>>>>>>>>>>>>>>>>>>>

When are you going to extend this theory of >>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves >>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem instead of merely solving >>>>>>>>>>>>>>>>>>>>>>>>>> the Olcott abort problem?

*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct >>>>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be >>>>>>>>>>>>>>>>>>>>>>>>> redefined.

But (2) is a LIE.

There is nothing "Incorrect" about the Halting >>>>>>>>>>>>>>>>>>>>>>>> Question.

Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this >>>>>>>>>>>>>>>>>>>>>>> second entity.

If Ĥ is your x86utm function D, then "yes" is the >>>>>>>>>>>>>>>>>>>>>> correct answer to all entities.

*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>>>

D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩
⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>

Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>>>

*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.

Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>> 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 }

Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.

It would be correct for this D. We can build another D, >>>>>>>>>>>>>>>> based on the new H, but then the question changes, >>>>>>>>>>>>>>>> because the input changes. The new H does not give the >>>>>>>>>>>>>>>> correct answer for the new D.

*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would >>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on >>>>>>>>>>>>>>>> the new H, but then the question changes, because the >>>>>>>>>>>>>>>> input changes. The new H does not give the correct >>>>>>>>>>>>>>>> answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would >>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on >>>>>>>>>>>>>>>> the new H, but then the question changes, because the >>>>>>>>>>>>>>>> input changes. The new H does not give the correct >>>>>>>>>>>>>>>> answer for the new D.

Both questions have a correct answer, but the
corresponding H failed to give it. It seems Olcott is >>>>>>>>>>>>>>>> again confused, because he uses the same names for >>>>>>>>>>>>>>>> different things.

Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.

Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>>>> attempt to get away with the strawman deception. >>>>>>>>>>>>>>>

Referring to a different D then the one you were given is >>>>>>>>>>>>>> a very lame attempt to get away with a strawman deception. >>>>>>>>>>>>>

I am specifying a single D and an infinite set of
implementations of H.

If you are still talking about the Linz proof instead of >>>>>>>>>>>> some bullshit, every D is based on exactly one H. If you >>>>>>>>>>>> change H but don't change D, the D is still based on the old >>>>>>>>>>>> H and the correct answer to the question "Does D(D) halt?" >>>>>>>>>>>> does not change.

Can D correctly simulated by H terminate normally?
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 }

If you want to construe this as an infinite set of H/D pairs >>>>>>>>>>> where you
are construing that each D is somehow different this makes no >>>>>>>>>>> difference
at all.

Every H(D,D) that doesn't abort its simulated input never >>>>>>>>>>> stops running.
Every H(D,D) that doesn't abort its simulated input never >>>>>>>>>>> stops running.
Every H(D,D) that doesn't abort its simulated input never >>>>>>>>>>> stops running.

Which STILL doesn't say what happens to the D's built on the >>>>>>>>>> Hs that DO Abort.

*All of them are on the correct side of the abort/no abort
decision*

Then why do they get the wrong answer?

Are you trying to get away with contradicting yourself?

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

On 3/20/24 6:01 PM, olcott wrote:

Every H(D,D) that doesn't abort its simulated input
never stops running.

;
Yep, shows that H's that don't abort the D built on
them won't be deciders...

Nothing contradictory about that.

You have two distinct classes of H, that make DIFFERENT errors due >>>>>> to different behaviors they create.

Those whose programming make them never abort create a D that will >>>>>> never halt, because its H get stuck in an infinite simulation
loop, the the top level H also gets stuck in. It NEEDS to abort,
but doesn't

Then you have those H whose programming makes themselves abort,
that create a D that calls an H that also aborts its simulation

Finally the right insertion point for these words. V3
So you don't understand that when the executed H does not abort that >>>>> none of them do because they are all the exact same code?

IF H is defined to not abort its simulation, then H will fail to be
a decider.

;that create a D that calls an H that also aborts its simulation <<< >>> No this is incorrect.

Unless the outermost H(D,D) aborts its simulation none of them
ever abort their simulation because they are all the exact same
machine-code.

Right, and that H fails to be a decider.

But if H does abort it simulation, then the fact that the other instances

Can't be the ones to abort because every H has the same machine-code
thus the executed H cannot wait for simulated H(D,D) to abort or no H
would ever abort. Your software engineering skill must be pretty weak.

Would a simulated program always do the same thing when simulated
without abort that it does do when directly executed?

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

XPost: sci.logic

On 3/22/24 12:27 AM, olcott wrote:

On 3/21/2024 10:10 PM, Richard Damon wrote:

Right, and that H fails to be a decider.

But if H does abort it simulation, then the fact that the other instances

Can't be the ones to abort because every H has the same machine-code
thus the executed H cannot wait for simulated H(D,D) to abort or no H
would ever abort. Your software engineering skill must be pretty weak.

How is "Every H" the same machine code?

I think you are confusing your lies.

The problem is that even if the "C function" D is the same machine code,
the fact that it calls an external H means the code of H affects its
behavior, and that must be taken into account.

You are just proving you ar just a STUPID LIAR that can't keep your
stories straight.

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

XPost: sci.logic

On 3/23/24 12:12 AM, olcott wrote:

On 3/22/2024 9:17 PM, Richard Damon wrote:

On 3/22/24 12:27 AM, olcott wrote:

On 3/21/2024 10:10 PM, Richard Damon wrote:

Right, and that H fails to be a decider.

But if H does abort it simulation, then the fact that the other
instances

Can't be the ones to abort because every H has the same machine-code
thus the executed H cannot wait for simulated H(D,D) to abort or no H
would ever abort. Your software engineering skill must be pretty weak.

How is "Every H" the same machine code?

Every H between the directly executed H and all of
its simulated H are the exact same machine code.

So? They are different execution instances so have their own identity.

If you didn't artificially limit your system to only being a TOY, then
the copy of the H that D uses could actually be different (but
equivalent) code.

Your problem is that you use "Every H" to mean two different things:

1) One is the instances withing a given program

2) The different versions you might try.

For 1), you need to remember that H is what it is, and needs to justify
its behavior based on that fact, and NOT what a 2) alternate might do.

SINCE our final H aborts its simulation, THAT IS what determines the
behavior of D, and for that D, THIS INSTANCE of H doesn't NEED to abort
its simulation, but does.

I think you are confusing your lies.

The problem is that even if the "C function" D is the same machine
code, the fact that it calls an external H means the code of H affects
its behavior, and that must be taken into account.

*Yes we are getting somewhere now* an actual honest dialogue.

So, you agree that D's behavior is affected by the H defined, and thus
you can't use other definitions of H to assert what this one does or
what we need to do to correctly process it.

You are just proving you ar just a STUPID LIAR that can't keep your
stories straight.

If that was true then I would not have just agreed with you.

Except that by agreeing to the principle, you ARE agreeing to the
conclusion.

And, it makes it clear that it is a deliberate fabrication, or utter
stupidity.

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