On 2024-03-23 14:20:17 +0000, olcott said:

> On 3/23/2024 6:11 AM, Mikko wrote:
>> On 2024-03-22 18:45:01 +0000, olcott said:
>>
>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>
>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>
>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
>>>>>>>>>>>>>> then not all these H are equal, but they are different. So two examples
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly equal in
>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>
>>>>>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>
>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Until this is understood one lacks the sufficient prerequisites to
>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>
>>>>>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>>>>>> must be reached.
>>>>>>>>>
>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>
>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>
>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>> No honest dialogue can be reasonable expected when you participate.
>>>>>>>>
>>>>>>>
>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>
>>>>>> I just note that you have rebutted nothing wirh reasoning or rhetoric.
>>>>>>
>>>>>
>>>>> Dogmatic statements do not count as reasoning.
>>>>
>>>> Dgmatic statements likn "Dogmatic statements do not count as reasoning"
>>>> do count as rhetoric.
>>>>
>>>> Observation of a fact is does not count as dogmatic.
>>>>
>>>
>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>> I am correct when I do this.
>>
>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>> any correct reasoning basis.
>>
>
> *So far no one has actually shown that*

On 2024-03-23 14:25:20 +0000, olcott said:

> On 3/23/2024 6:14 AM, Mikko wrote:
>> On 2024-03-22 18:43:39 +0000, olcott said:
>>
>>> On 3/22/2024 1:30 PM, Mikko wrote:
>>>> On 2024-03-22 15:44:35 +0000, olcott said:
>>>>
>>>>> On 3/22/2024 2:54 AM, Mikko wrote:
>>>>>> On 2024-03-21 18:26:44 +0000, olcott said:
>>>>>>
>>>>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>>>>> On 21/03/24 05:37, olcott wrote:
>>>>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>>>>> On 21/03/24 04:59, olcott wrote:
>>>>>>>>>>> On 3/20/2024 10:55 PM, immibis wrote:
>>>>>>>>>>>> On 21/03/24 03:50, 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 and returns
>>>>>>>>>>>>>> causse that D to Halt. Thus this H, will it aborts its simulation,
>>>>>>>>>>>>>> didn't NEED to abort it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Didn't you say H was an infinite set of different programs?
>>>>>>>>>>>
>>>>>>>>>>> Yes I said this. They all simulate their input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So you don't understand that different programs are not all the exact
>>>>>>>>>> same code.
>>>>>>>>>
>>>>>>>>> All of the simulated H(D,D) operate exactly the way that the
>>>>>>>>> executed one does because it is the exact same code.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So if we skip the abort instruction of the outer H in a debugger then
>>>>>>>> none of them will abort?
>>>>>>>
>>>>>>> If we ever skip the abort instruction we must do it in every H or
>>>>>>> we are cheating. Mike was probably not aware that he was cheating
>>>>>>> when he suggested skipping the outer one of them.
>>>>>>
>>>>>> We can cheat when we use a debugger.
>>>>>>
>>>>>
>>>>> Yes and you understand that is cheating, good for you.
>>>>
>>>> It is a debugging trick that can be used to determine whether a particular
>>>> correction might fix the bug. Usually other methods are better but in
>>>> debugging one must be creative.
>>>>
>>>> But the interesting question is what happens if you do as immibis
>>>> proposed.
>>>>
>>>
>>> That same "debugging trick" causes the halting problem proofs
>>> to fail because it causes H(D,D) == Halts(D,D).
>>
>> "Cause" only in the same sense magic words cause a rabit to
>> come out of the magician's empty hat.
>>
>
> "Cause" in the sense of semantically entails.
> When you knock over a bucket of oat this causes
> the bucket of oats to be knocked over.
>
> When the executed H is allowed to have different behavior
> than its simulated version then the halting problem would
> be solved by this cheat.
>
> It is not actually solved because it is a cheat.

On 3/23/2024 10:58 AM, Mikko wrote:
> On 2024-03-23 14:02:45 +0000, olcott said:
>
>> On 3/23/2024 5:54 AM, Mikko wrote:
>>> On 2024-03-22 18:50:17 +0000, olcott said:
>>>
>>>> On 3/22/2024 1:41 PM, Mikko wrote:
>>>>> On 2024-03-22 15:41:40 +0000, olcott said:
>>>>>
>>>>>> On 3/22/2024 2:44 AM, Mikko wrote:
>>>>>>> On 2024-03-22 03:21:57 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/21/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>> On 3/21/24 10:06 AM, olcott wrote:
>>>>>>>>>> On 3/21/2024 4:39 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-20 16:38:31 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/20/2024 10:27 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 13:34:01 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/20/2024 3:12 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-20 03:03:33 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/19/2024 11:03 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-18 22:50:54 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-17 16:35:32 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:09 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-17 13:53:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Best selling author of Theory of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation textbooks:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to anything else in this paper)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and correctly report that D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (elaborated above)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your simulation?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   machine   stack     stack
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine assembly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   address   address   data      code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   ========  ========  ========
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp      ; begin main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored at:113075
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp       ; enter D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax       ; push D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx       ; push D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e81ff8ffff call 00001522  ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>                            H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0 to main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> itself is being called with its same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs and there are no conditional
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> branch instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove the required (a), since the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated D WILL stop running because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *ITS* H will abort *ITS* simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and returm 0 so that simulated D will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> really needs to abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input because after
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) has aborted the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input it no longer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> needs to be aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep thinking there is more than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one H(D,D) and then when it's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> convenient for you you think there is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only one H(D,D). Why is that?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The first H(D,D) to see that the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has been met
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the outermost one) must abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was baffled by this for three days when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I first investigated this.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because every H has the exact same code,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if the first one to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the abort criteria has been met does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort then none of them abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus you look at a strawman. A case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> where H isn't the H that we started with.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you change the H used by D, you change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the quesition being asked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> We cannot reference the behavior of what
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) does after H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> has already aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at the point
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in time before H(D,D) aborts its input as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> any criterion measure
>>>>>>>>>>>>>>>>>>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then you cannot prove that H is a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, as that is what
>>>>>>>>>>>>>>>>>>>>>>>>>>> you need to reference in the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I am saying that H(D,D)==0 is correct in that
>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D)==0 means
>>>>>>>>>>>>>>>>>>>>>>>>>> that H correctly determined that it had to
>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite execution
>>>>>>>>>>>>>>>>>>>>>>>>>> of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> There cannot possibly exist any H(D,D) that is
>>>>>>>>>>>>>>>>>>>>>>>>>> called by
>>>>>>>>>>>>>>>>>>>>>>>>>> D where H(D,D) simulates its input and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> stops running
>>>>>>>>>>>>>>>>>>>>>>>>>> and H never aborts its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The set from wich such H could be chosen is so
>>>>>>>>>>>>>>>>>>>>>>>>> small that
>>>>>>>>>>>>>>>>>>>>>>>>> it is no surprise that any H that simulates
>>>>>>>>>>>>>>>>>>>>>>>>> D(D) to its
>>>>>>>>>>>>>>>>>>>>>>>>> termination is not in that set.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> As soon as we hit complete proof of this we can
>>>>>>>>>>>>>>>>>>>>>>>> move on
>>>>>>>>>>>>>>>>>>>>>>>> to another point.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> A complete proof of what?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is possible that you don't find such proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Been there done that many times.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You have presented nothing that even looks like
>>>>>>>>>>>>>>>>>>> proof, let alone is.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That you don't understand that this is proof does not
>>>>>>>>>>>>>>>>>> entail that it is not proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes it does. I know how a proof looks.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A proof is a non-empty sequence of sentences, each of
>>>>>>>>>>>>>>>>> which is either
>>>>>>>>>>>>>>>>> an axiom, a postulate, a hypothesis, an assumption, a
>>>>>>>>>>>>>>>>> definition, or
>>>>>>>>>>>>>>>>> a result of an application of a valid inference rule to
>>>>>>>>>>>>>>>>> earlier sentences
>>>>>>>>>>>>>>>>> in the same proof. The last sentence in proof is the
>>>>>>>>>>>>>>>>> conclusion of the
>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>> Line 03: 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 03.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> All halt deciders must compute the mapping from the
>>>>>>>>>>>>>>>> behavior that its
>>>>>>>>>>>>>>>> finite string specifies... D specifies that N to ∞ steps
>>>>>>>>>>>>>>>> of D correctly
>>>>>>>>>>>>>>>> simulated by H cannot possibly reach the final state of
>>>>>>>>>>>>>>>> D at line (6),
>>>>>>>>>>>>>>>> thus D specifies non-halting behavior.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, all halt deciders compute the mapping that the halt
>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet when I provide a concrete example proving that I am
>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>> all you have is dogma instead of reasoning.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The problem is what it is. No reasoning can change it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When one assumes that the inability to do the logically
>>>>>>>>>>>> impossible
>>>>>>>>>>>> places an actual limit on anyone or anything then the
>>>>>>>>>>>> inability to
>>>>>>>>>>>> answer this question: What time is it (yes or no) ?
>>>>>>>>>>>>
>>>>>>>>>>>> places the same limit on humans that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ != Halt(Ĥ,
>>>>>>>>>>>> ⟨Ĥ⟩) places
>>>>>>>>>>>> on computation.
>>>>>>>>>>>
>>>>>>>>>>> Yes, though the requirement in the former case is not as
>>>>>>>>>>> formal as in
>>>>>>>>>>> the latter. Humans can of course answer whichever way they
>>>>>>>>>>> want or not
>>>>>>>>>>> at all, and then it its the questioners problem to decide
>>>>>>>>>>> what to do
>>>>>>>>>>> with the given anser. In the latter case it is more clear:
>>>>>>>>>>> that Ĥ.H
>>>>>>>>>>> does not give the right answer means that it is not a halt
>>>>>>>>>>> decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That it is logically impossible for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ == Halt(Ĥ,
>>>>>>>>>> ⟨Ĥ⟩) places a
>>>>>>>>>> limit on computation in that it is logically impossible thus
>>>>>>>>>> exactly the
>>>>>>>>>> same as the inability for anyone of anything to correctly
>>>>>>>>>> answer this
>>>>>>>>>> question: What time is it (yes or no)?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The fact that we know it is logically impossible doesn't affect
>>>>>>>>> what can be done, since it never could be done in the first place.
>>>>>>>>>
>>>>>>>>> KNOWING it can't be done, is KNOWLEDGE that can help us direct
>>>>>>>>> our efforts where they may be more usefully used.
>>>>>>>>>
>>>>>>>>> If you paid attention to that, you wouldn't have wasted the
>>>>>>>>> last 20 years of your life and destroyed your reputation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Everyone honest believes that there are very simple things that
>>>>>>>> computers cannot do.
>>>>>>>
>>>>>>> Depends on the interpretation of "very simple". The question whether
>>>>>>> some conjecture is true or false may sound simple even if the
>>>>>>> defintion of that conjecture isn't.
>>>>>>>
>>>>>>>> They never realize that there is no theoretical
>>>>>>>> reason why computers cannot simultaneously exceed the best human
>>>>>>>> exceed all of the best experts in every human field on knowledge
>>>>>>>> by 100,000-fold.
>>>>>>>
>>>>>>> However there is a good theoretical reason (i.e., a proof) that
>>>>>>> showhs that they cannot solve the halting problem.
>>>>>>>
>>>>>>
>>>>>> An omniscient AI would point out the inconsistency in requiring a
>>>>>> decider to do the logically impossible and would reformulate the
>>>>>> foundations of computation to abolish this inconsistency the same
>>>>>> way the ZFC abolish Russell's Paradox.
>>>>>>
>>>>>>>> That computers can't solve problems as easy as the Liar Paradox
>>>>>>>> gives people a false impression of the actual limits of
>>>>>>>> computation.
>>>>>>>
>>>>>>> The Liar's Paradox is not a computational problem. If you need to
>>>>>>> design a new formal system then you may want to be sure that your
>>>>>>> language cannot express the Liar Paradox or at least needn't give
>>>>>>> it a truth value.
>>>>>>>
>>>>>>
>>>>>> In other words you are unaware that Tarski anchored his
>>>>>> undefinability theorem in the undecidability of the Liar Paradox.
>>>>>
>>>>> I don't think "anchored" is a good word here. Tarski's proof
>>>>> was about logic, not ships.
>>>>>
>>>>
>>>>
>>>> The foundational basis of Tarski's proof is the undecidability
>>>> of the Liar Paradox.
>>>
>>> You apparently disagree with Tarski's opinion that the Liar's
>>> paradox cannot be true.
>>>
>>
>> This sentence is not true: "This sentence is not true." is true
>> because the inner sentence is not a truth bearer.
>>
>> ?- LP = not(true(LP)).
>> LP = not(true(LP)).
>>
>> ?- unify_with_occurs_check(LP, not(true(LP))).
>> false.
>>
>> Unlike Tarski Prolog understands that any expression having the
>> same structure as the Liar Paradox must be rejected as not a
>> truth bearer.
>
> So what's wrong in rejecting liar's paradox as Tarski did?
>

On 3/23/2024 11:05 AM, Mikko wrote:
> On 2024-03-23 14:09:35 +0000, olcott said:
>
>> On 3/23/2024 6:07 AM, Mikko wrote:
>>> On 2024-03-22 21:22:55 +0000, olcott said:
>>>
>>>> On 3/22/2024 4:17 PM, immibis wrote:
>>>>> On 22/03/24 22:01, olcott wrote:
>>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>>> On 22/03/24 20:49, olcott wrote:
>>>>>>>> The false assumption that a halt decider must report on behavior
>>>>>>>> that is different than the behavior that it actually sees.
>>>>>>>>
>>>>>>> That is a true assumption. That is the specification of a halt
>>>>>>> decider. It must report whether a program would ever halt even
>>>>>>> though it cannot see whether a program would ever halt.
>>>>>>
>>>>>> That contradicts the correct definition of a decider that
>>>>>> must compute the mapping from its input on the basis of a
>>>>>> (in this case semantic) property of this input.
>>>>>
>>>>> It does not contradict.
>>>>>
>>>>>> Since D does specify non-halting behavior to H then H(D,D)
>>>>>> is necessarily correct to reject this input as non-halting.
>>>>>
>>>>> D specifies a program which halts when executed.
>>>>
>>>> That the simulation of D must be aborted by H to prevent its own
>>>> infinite execution conclusively proves that D specifies non-halting
>>>> behavior to H. *The only "rebuttals" to this are damned lies*
>>>
>>> Linz and many others have proven that there are no halt deciders.
>>> Olcott's only "rebuttals" to this are damned lies.
>>>
>>
>> You can't even found an actual mistake and have the audacity
>> to call me a liar?
>
> Both mistakes and lies have been found and pointed out. No need
> to repeat.
>
> What matters is that you have't retracted your claim that Linz
> made a mistake that you can't point out.
>

*I think that I remember that we are at this point now*
Linz did not make a mistake within the mistaken notions of the
foundation of computation.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

A possible mistake that many authors have made within the current
notions of the foundations of computation is that these authors do
not understand that deciders must compute the mapping from their
actual inputs to their own accept or reject state on the basis of
the actual behavior specified by these inputs.

Nicholas J. Macias. *Context-Dependent Functions*
Narrowing the Realm of Turing’s Halting Problem
13 Nov 2014
https://arxiv.org/abs/1501.03018
arXiv:1501.03018 [cs.LO]

The concept of a "Context-Dependent Function" (CDF),
whose behavior varies based on seemingly irrelevant
changes to a program calling that function, is introduced,
and the proof of HP's undecidability is re-examined in
light of CDFs. (quoted from the above paper)

On 3/22/2024 9:17 PM, Richard Damon wrote:
>
> 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.

The behavior of D correctly simulated by H cannot possibly
halt whereas the behavior of D correctly simulated by H1 halts.

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

On 3/23/2024 11:07 AM, Mikko wrote:
> On 2024-03-23 14:05:09 +0000, olcott said:
>
>> On 3/23/2024 6:04 AM, Mikko wrote:
>>> On 2024-03-22 19:49:09 +0000, olcott said:
>>>
>>>> On 3/22/2024 2:45 PM, immibis wrote:
>>>>> On 22/03/24 19:46, olcott wrote:
>>>>>> On 3/22/2024 1:35 PM, Mikko wrote:
>>>>>>> On 2024-03-22 15:43:04 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/22/2024 2:50 AM, Mikko wrote:
>>>>>>>>> On 2024-03-21 16:34:02 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but
>>>>>>>>>>>>>>>>> they are different. So two examples
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>
>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>> agreement
>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>
>>>>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>
>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>
>>>>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>> participate.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> In other words you misconstrue rhetoric as a kind of reasoning
>>>>>>>>>> that can be applied to rebutting logical arguments.
>>>>>>>>>
>>>>>>>>> I misconstrue nothong you say as any kind of reasoning.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yet can't correctly point out any errors.
>>>>>>>
>>>>>>> It is sufficient to note that you claim that various proofs are
>>>>>>> erroneous without pointing out any errors.
>>>>>>>
>>>>>>
>>>>>> That the various proofs are correct within their false assumptions
>>>>>> provides zero evidence that they are correct.
>>>>>>
>>>>> Assumptions such as "every program/input pair either halts or
>>>>> doesn't halt"?
>>>>
>>>> The false assumption that a halt decider must report on behavior
>>>> that is different than the behavior that it actually sees.
>>>
>>> The false assumption is that a halt decider must report in behaviour
>>> it acutally hallucinates even when that is different from the behaviour
>>> specified by the input.
>>>
>>
>> In other words you had no clue that all deciders must compute the
>> mapping from their actual inputs. You cannot use your own ignorance
>> as a correct basis for any rebuttal.
>
> Not just a mappaing but the one mapping required by the specificaiton
> of the particular type of decider.
>

On 3/23/2024 11:12 AM, Mikko wrote:
> On 2024-03-23 14:20:17 +0000, olcott said:
>
>> On 3/23/2024 6:11 AM, Mikko wrote:
>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>
>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>
>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but they
>>>>>>>>>>>>>>> are different. So two examples
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly
>>>>>>>>>>>>>> equal in
>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>
>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>> prerequisites to
>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>
>>>>>>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>>>>>>> must be reached.
>>>>>>>>>>
>>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>
>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>
>>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>> participate.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>
>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>> rhetoric.
>>>>>>>
>>>>>>
>>>>>> Dogmatic statements do not count as reasoning.
>>>>>
>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>> reasoning"
>>>>> do count as rhetoric.
>>>>>
>>>>> Observation of a fact is does not count as dogmatic.
>>>>>
>>>>
>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>> I am correct when I do this.
>>>
>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>> any correct reasoning basis.
>>>
>>
>> *So far no one has actually shown that*
>
> Suffiecent evidence can be found in recent messages in comp.theory.
> ANyone is free to ask if something remains unclear. But it seems
> that everithing is sufficiently clear to most participants.
>

On 3/23/2024 11:15 AM, Mikko wrote:
> On 2024-03-23 14:25:20 +0000, olcott said:
>
>> On 3/23/2024 6:14 AM, Mikko wrote:
>>> On 2024-03-22 18:43:39 +0000, olcott said:
>>>
>>>> On 3/22/2024 1:30 PM, Mikko wrote:
>>>>> On 2024-03-22 15:44:35 +0000, olcott said:
>>>>>
>>>>>> On 3/22/2024 2:54 AM, Mikko wrote:
>>>>>>> On 2024-03-21 18:26:44 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>>>>>> On 21/03/24 05:37, olcott wrote:
>>>>>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>>>>>> On 21/03/24 04:59, olcott wrote:
>>>>>>>>>>>> On 3/20/2024 10:55 PM, immibis wrote:
>>>>>>>>>>>>> On 21/03/24 03:50, 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 and returns causse that D to Halt. Thus
>>>>>>>>>>>>>>> this H, will it aborts its simulation, didn't NEED to
>>>>>>>>>>>>>>> abort it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Didn't you say H was an infinite set of different programs?
>>>>>>>>>>>>
>>>>>>>>>>>> Yes I said this. They all simulate their input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So you don't understand that different programs are not all
>>>>>>>>>>> the exact same code.
>>>>>>>>>>
>>>>>>>>>> All of the simulated H(D,D) operate exactly the way that the
>>>>>>>>>> executed one does because it is the exact same code.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So if we skip the abort instruction of the outer H in a
>>>>>>>>> debugger then none of them will abort?
>>>>>>>>
>>>>>>>> If we ever skip the abort instruction we must do it in every H or
>>>>>>>> we are cheating. Mike was probably not aware that he was cheating
>>>>>>>> when he suggested skipping the outer one of them.
>>>>>>>
>>>>>>> We can cheat when we use a debugger.
>>>>>>>
>>>>>>
>>>>>> Yes and you understand that is cheating, good for you.
>>>>>
>>>>> It is a debugging trick that can be used to determine whether a
>>>>> particular
>>>>> correction might fix the bug. Usually other methods are better but in
>>>>> debugging one must be creative.
>>>>>
>>>>> But the interesting question is what happens if you do as immibis
>>>>> proposed.
>>>>>
>>>>
>>>> That same "debugging trick" causes the halting problem proofs
>>>> to fail because it causes H(D,D) == Halts(D,D).
>>>
>>> "Cause" only in the same sense magic words cause a rabit to
>>> come out of the magician's empty hat.
>>>
>>
>> "Cause" in the sense of semantically entails.
>> When you knock over a bucket of oat this causes
>> the bucket of oats to be knocked over.
>>
>> When the executed H is allowed to have different behavior
>> than its simulated version then the halting problem would
>> be solved by this cheat.
>>
>> It is not actually solved because it is a cheat.
>
> So far the nearest you have come to a solution is a halt decider
> that sheats but still fails.
>

On 3/23/24 10:41 AM, olcott wrote:
> On 3/23/2024 9:18 AM, Richard Damon wrote:
>> On 3/23/24 10:09 AM, olcott wrote:
>>> On 3/23/2024 6:07 AM, Mikko wrote:
>>>> On 2024-03-22 21:22:55 +0000, olcott said:
>>>>
>>>>> On 3/22/2024 4:17 PM, immibis wrote:
>>>>>> On 22/03/24 22:01, olcott wrote:
>>>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>>>> On 22/03/24 20:49, olcott wrote:
>>>>>>>>> The false assumption that a halt decider must report on behavior
>>>>>>>>> that is different than the behavior that it actually sees.
>>>>>>>>>
>>>>>>>> That is a true assumption. That is the specification of a halt
>>>>>>>> decider. It must report whether a program would ever halt even
>>>>>>>> though it cannot see whether a program would ever halt.
>>>>>>>
>>>>>>> That contradicts the correct definition of a decider that
>>>>>>> must compute the mapping from its input on the basis of a
>>>>>>> (in this case semantic) property of this input.
>>>>>>
>>>>>> It does not contradict.
>>>>>>
>>>>>>> Since D does specify non-halting behavior to H then H(D,D)
>>>>>>> is necessarily correct to reject this input as non-halting.
>>>>>>
>>>>>> D specifies a program which halts when executed.
>>>>>
>>>>> That the simulation of D must be aborted by H to prevent its own
>>>>> infinite execution conclusively proves that D specifies non-halting
>>>>> behavior to H. *The only "rebuttals" to this are damned lies*
>>>>
>>>> Linz and many others have proven that there are no halt deciders.
>>>> Olcott's only "rebuttals" to this are damned lies.
>>>>
>>>
>>> You can't even found an actual mistake and have the audacity
>>> to call me a liar?
>>>
>>> Your last "rebuttal" was anchored in your ignorance about
>>> how deciders are actually defined to work. They must compute
>>> the mapping form their actual inputs.
>>>
>>
>> Right, and since D,D specifies the program D(D) and that Halts,
>
> 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 }
>
> Since you know that D(D) correctly simulated by H cannot
> possibly halt, why lie about this and use the strawman
> deception to refer to an instance of D(D) that does not
> even exist in the above computation?
>

Because since you H no longer correctly simulates because it aborts,
that criteria no onger holds. The fact that the ACTUAL CORRECT
simulation of this input, when H is defined to abort and return 0 as it
is, will halt, shows that H is just incoorect.

You are just proving you have no idea how to do logic at all.

THere goes any hope of people looking at your "Correct Reasoning" when
it is shown to be based on invalid logic and lies.

On 3/23/24 10:20 AM, olcott wrote:
> On 3/23/2024 6:11 AM, Mikko wrote:
>> On 2024-03-22 18:45:01 +0000, olcott said:
>>
>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>
>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>
>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but they
>>>>>>>>>>>>>> are different. So two examples
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly
>>>>>>>>>>>>> equal in
>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>
>>>>>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>
>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Until this is understood one lacks the sufficient prerequisites to
>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>
>>>>>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>>>>>> must be reached.
>>>>>>>>>
>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>
>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>
>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>> No honest dialogue can be reasonable expected when you participate.
>>>>>>>>
>>>>>>>
>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>
>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>> rhetoric.
>>>>>>
>>>>>
>>>>> Dogmatic statements do not count as reasoning.
>>>>
>>>> Dgmatic statements likn "Dogmatic statements do not count as reasoning"
>>>> do count as rhetoric.
>>>>
>>>> Observation of a fact is does not count as dogmatic.
>>>>
>>>
>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>> I am correct when I do this.
>>
>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>> any correct reasoning basis.
>>
>
> *So far no one has actually shown that*
> Mike attempted to show that every member of a class of functions that
> have a common property can't make the same decision based on this common
> property because irrelevant differences that do not pertain to this
> property would change the correctness of the decision.
>
> Most of the recent "rebuttals" copied this same mistake.
>
> 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 }
>
> 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...
>
> Therefore the executed H(D,D) is correct to abort its simulated
> D(D) because it sees that it will never otherwise terminate.
>

Op 23.mrt.2024 om 17:42 schreef olcott:
> On 3/23/2024 11:12 AM, Mikko wrote:
>> On 2024-03-23 14:20:17 +0000, olcott said:
>>
>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>
>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>
>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but they
>>>>>>>>>>>>>>>> are different. So two examples
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>
>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>> prerequisites to
>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>
>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>> agreement
>>>>>>>>>>> must be reached.
>>>>>>>>>>>
>>>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>
>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>
>>>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>> participate.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>>
>>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>>> rhetoric.
>>>>>>>>
>>>>>>>
>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>
>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>> reasoning"
>>>>>> do count as rhetoric.
>>>>>>
>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>
>>>>>
>>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>>> I am correct when I do this.
>>>>
>>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>>> any correct reasoning basis.
>>>>
>>>
>>> *So far no one has actually shown that*
>>
>> Suffiecent evidence can be found in recent messages in comp.theory.
>> ANyone is free to ask if something remains unclear. But it seems
>> that everithing is sufficiently clear to most participants.
>>
>
> 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 }
>
> For the entire set of every implmentation of H where H simulates
> its input no D can possibly reach its own final state at line 06
> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*

On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
> Op 23.mrt.2024 om 17:42 schreef olcott:
>> On 3/23/2024 11:12 AM, Mikko wrote:
>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>
>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>
>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but
>>>>>>>>>>>>>>>>> they are different. So two examples
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>
>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>> agreement
>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>
>>>>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>
>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>
>>>>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>> participate.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>>>
>>>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>>>> rhetoric.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>
>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>> reasoning"
>>>>>>> do count as rhetoric.
>>>>>>>
>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>
>>>>>>
>>>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>>>> I am correct when I do this.
>>>>>
>>>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>>>> any correct reasoning basis.
>>>>>
>>>>
>>>> *So far no one has actually shown that*
>>>
>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>> ANyone is free to ask if something remains unclear. But it seems
>>> that everithing is sufficiently clear to most participants.
>>>
>>
>> 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 }
>>
>> For the entire set of every implmentation of H where H simulates
>> its input no D can possibly reach its own final state at line 06
>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>
> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING* either.
> So, an aborted simulation cannot prove that an abort is required.
>

On 3/23/24 3:25 PM, olcott wrote:
> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>
>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>
>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but
>>>>>>>>>>>>>>>>>> they are different. So two examples
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>>> agreement
>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>
>>>>>>>>>>>> In sufficient as you have provided much more contrary evidence.
>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>> participate.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>>>>
>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>>>>> rhetoric.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>
>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>>> reasoning"
>>>>>>>> do count as rhetoric.
>>>>>>>>
>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>
>>>>>>>
>>>>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>>>>> I am correct when I do this.
>>>>>>
>>>>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>>>>> any correct reasoning basis.
>>>>>>
>>>>>
>>>>> *So far no one has actually shown that*
>>>>
>>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>>> ANyone is free to ask if something remains unclear. But it seems
>>>> that everithing is sufficiently clear to most participants.
>>>>
>>>
>>> 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 }
>>>
>>> For the entire set of every implmentation of H where H simulates
>>> its input no D can possibly reach its own final state at line 06
>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>
>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING* either.
>> So, an aborted simulation cannot prove that an abort is required.
>>
>
> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
> That is merely yet another instance of the strawman deception.
> We never have been talking about an arbitrary aborted simulation.

On 3/23/2024 4:02 PM, Richard Damon wrote:
> On 3/23/24 3:25 PM, olcott wrote:
>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>
>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks
>>>>>>>>>>>>>>>>>>> about 'every H' then not all these H are equal, but
>>>>>>>>>>>>>>>>>>> they are different. So two examples
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>>>> agreement
>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I admitted that I was wrong about the details of some things:
>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>
>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>>>>>
>>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>>>>>> rhetoric.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>
>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>>>> reasoning"
>>>>>>>>> do count as rhetoric.
>>>>>>>>>
>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>>>>>> I am correct when I do this.
>>>>>>>
>>>>>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>>>>>> any correct reasoning basis.
>>>>>>>
>>>>>>
>>>>>> *So far no one has actually shown that*
>>>>>
>>>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>> that everithing is sufficiently clear to most participants.
>>>>>
>>>>
>>>> 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 }
>>>>
>>>> For the entire set of every implmentation of H where H simulates
>>>> its input no D can possibly reach its own final state at line 06
>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>
>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING* either.
>>> So, an aborted simulation cannot prove that an abort is required.
>>>
>>
>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>> That is merely yet another instance of the strawman deception.
>> We never have been talking about an arbitrary aborted simulation.
>
> Right, H aborting its simulation doesn't make the input Non-Halting,
> that is based on the DIRECT EXECUTION of that input exactly as it was
> presented to H, that is, calling the H that it was originally calling.
> (the one claimed to give the right answer)
>
>>
>> We have only been talking about a simulation of D by H that cannot
>> possibly reach its own final state at line 06 in an infinite number
>> of steps of correct simulation.
>
> Then I guess you are admitting that you only H just fails to be a
> decider, since it actually does just simulate its input for an infinite
> number of steps.
>
> I guess you are done and admit defeat.
>
> Now, I KNOW you are just lying, because you are ACTUALLY going to say
> that now that we have established this is what D does, H can be changed
> to abort, but then we have to throw out that conclusion, as D changes
> when we change H.
>
>
> So, if H DOES abort its simulation then this aborting does NOT, by
> itself make D non-halting, but we need to look at what D actually does.
>
> If D aborts its simulation and call the input non-halting, then D will
> halt, and thus H was just INCORRECT to have aborted its simulation, as
> this new behavior of D was established when we changed H, so NOW it is
> not correct to abort its simulation
>
>>
>> Everyone with sufficient programming skill can see that this is a
>> verified fact:
>>
>> *D correctly simulated by H cannot possibly reach its own final state*
>> *at line 06 in an infinite number of steps of correct simulation*
>> Some of these people might lie about it.
>>
>
> Right, so if H does correctly simulate D, then it doesn't abort and
> fails to be a decider.
>

On 23/03/24 22:08, olcott wrote:
> On 3/23/2024 4:02 PM, Richard Damon wrote:
>> On 3/23/24 3:25 PM, olcott wrote:
>>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>>
>>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he
>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are
>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>>>>> agreement
>>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I admitted that I was wrong about the details of some
>>>>>>>>>>>>>>> things:
>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>>>>>>
>>>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>>>>>>> rhetoric.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>>
>>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>>>>> reasoning"
>>>>>>>>>> do count as rhetoric.
>>>>>>>>>>
>>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>>>>>>> I am correct when I do this.
>>>>>>>>
>>>>>>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>>>>>>> any correct reasoning basis.
>>>>>>>>
>>>>>>>
>>>>>>> *So far no one has actually shown that*
>>>>>>
>>>>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>>> that everithing is sufficiently clear to most participants.
>>>>>>
>>>>>
>>>>> 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 }
>>>>>
>>>>> For the entire set of every implmentation of H where H simulates
>>>>> its input no D can possibly reach its own final state at line 06
>>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>>
>>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING*
>>>> either.
>>>> So, an aborted simulation cannot prove that an abort is required.
>>>>
>>>
>>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>>> That is merely yet another instance of the strawman deception.
>>> We never have been talking about an arbitrary aborted simulation.
>>
>> Right, H aborting its simulation doesn't make the input Non-Halting,
>> that is based on the DIRECT EXECUTION of that input exactly as it was
>> presented to H, that is, calling the H that it was originally calling.
>> (the one claimed to give the right answer)
>>
>>>
>>> We have only been talking about a simulation of D by H that cannot
>>> possibly reach its own final state at line 06 in an infinite number
>>> of steps of correct simulation.
>>
>> Then I guess you are admitting that you only H just fails to be a
>> decider, since it actually does just simulate its input for an
>> infinite number of steps.
>>
>> I guess you are done and admit defeat.
>>
>> Now, I KNOW you are just lying, because you are ACTUALLY going to say
>> that now that we have established this is what D does, H can be
>> changed to abort, but then we have to throw out that conclusion, as D
>> changes when we change H.
>>
>>
>> So, if H DOES abort its simulation then this aborting does NOT, by
>> itself make D non-halting, but we need to look at what D actually does.
>>
>> If D aborts its simulation and call the input non-halting, then D will
>> halt, and thus H was just INCORRECT to have aborted its simulation, as
>> this new behavior of D was established when we changed H, so NOW it is
>> not correct to abort its simulation
>>
>>>
>>> Everyone with sufficient programming skill can see that this is a
>>> verified fact:
>>>
>>> *D correctly simulated by H cannot possibly reach its own final state*
>>> *at line 06 in an infinite number of steps of correct simulation*
>>> Some of these people might lie about it.
>>>
>>
>> Right, so if H does correctly simulate D, then it doesn't abort and
>> fails to be a decider.
>>
>
> *Like I said some people might lie about it*
> H does correctly simulate D until it can see that every D simulated
> by any H cannot possibly halt. Then H has its correct basis to abort
> its simulation of D and reject D as non-halting.
>

On 23/03/24 17:45, olcott wrote:
> I have come up with a decidability decider that refutes Rice and
> everyone uses a deceptive ruse to avoid even talking about this:
>
> Of all of the elements of the set of H(D,D) where H simulates its
> input there are matched pairs of otherwise identical elements that
> only differ by whether they abort their simulation or not.

There are two types of bug-free program: those which are so simple there
are obviously no bugs, and those which are so complicated there are no
obvious bugs. Since you are the world's greatest software engineer who
ever existed, and since you are literally God (who is allowed to possess
child pornography according to you), you must already know this.

There are two types of proof steps: those which are so simple there are
obviously no mistakes and those which are so complicated there are no
obvious mistakes. The great achievement of mathematics has been breaking
down complicated proofs into steps that are so simple they are obviously
correct. This is why Turing machines are defined the way they are
defined. They are so simple there is no room for mistakes. Sometimes
there is disagreement about whether a step is simple enough, and it has
to be split into even simpler steps.

Your style of proof is that you make the steps so complicated that
nobody can figure out what you meant and you can always contradict what
someone says about them. When you say things like "H aborts because it
proves something happens unless H aborts" this is complicated and
unclear. H aborts so saying that something happens unless H aborts is
like saying that something happens unless the moon is made of moon
rocks. The moon IS made of moon rocks so it is useless. I know olcott
isn't going to read this purple monkey dishwasher. If you wanted to be
clear you would talk about other Hs which abort. For some reason you
also have this idea that D always calls the same H that is simulating
it, which is simply not how Turing machines work. If you follow the
Turing machine proof, D calls the one that has a copy embedded into D,
and simulating D with a different H doesn't change which H D actually
calls. This paragraph is overly long to hide the secret sentence. Once
again mathematicians made this simple so there can be obviously no bugs
and you just insist on making things excessively complicated so whatever
someone says, you have room to contradict it by saying you actually
meant something else.

> The half of these that don't abort are incorrect because all deciders
> must halt. This makes the other half correct about the abort/no abort
> decision.

Half of my students think 1+1=4 and they are wrong. This makes the other
half, who think that 2+2=2, correct.

On 23/03/24 15:41, olcott wrote:
> On 3/23/2024 9:18 AM, Richard Damon wrote:
>> Right, and since D,D specifies the program D(D) and that Halts,
>
> Since you know that D(D) correctly simulated by H cannot
> possibly halt, why lie about this and use the strawman
> deception to refer to an instance of D(D) that does not
> even exist in the above computation?
>
The halting problem is about whether a program halts not whether a
"correct simulation" of that program halts.

On 23/03/24 14:54, olcott wrote:
> On 3/23/2024 3:01 AM, immibis wrote:
>> On 22/03/24 06:23, olcott wrote:
>>> On 3/21/2024 11:58 PM, immibis wrote:
>>>> On 22/03/24 05:36, olcott wrote:
>>>>> On 3/21/2024 11:18 PM, immibis wrote:
>>>>>> On 22/03/24 05:06, olcott wrote:
>>>>>>> On 3/21/2024 10:40 PM, immibis wrote:
>>>>>>>> On 22/03/24 02:44, olcott wrote:
>>>>>>>>> On 3/21/2024 8:25 PM, immibis wrote:
>>>>>>>>>> On 21/03/24 22:05, olcott wrote:
>>>>>>>>>>> On 3/21/2024 3:39 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 21.mrt.2024 om 21:15 schreef olcott:
>>>>>>>>>>>>> On 3/21/2024 2:46 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 21.mrt.2024 om 19:26 schreef olcott:
>>>>>>>>>>>>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So if we skip the abort instruction of the outer H in a
>>>>>>>>>>>>>>>> debugger then none of them will abort?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If we ever skip the abort instruction we must do it in
>>>>>>>>>>>>>>> every H or
>>>>>>>>>>>>>>> we are cheating.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not at all. If we skip the abort instruction in the
>>>>>>>>>>>>>> simulating H, we only change the decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> The definition of the problem requires every H to behave in
>>>>>>>>>>>>> exactly
>>>>>>>>>>>>> the same way.
>>>>>>>>>>>>
>>>>>>>>>>>> Self-contradicting definitions should be rejected. Some H
>>>>>>>>>>>> return yes, other return no. So, not every H behaves in
>>>>>>>>>>>> exactly the same way.
>>>>>>>>>>>
>>>>>>>>>>> The problem definition requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to behave in exactly
>>>>>>>>>>> the same way as H ⟨Ĥ⟩ ⟨Ĥ⟩ for each corresponding H/Ĥ pair.
>>>>>>>>>>>
>>>>>>>>>>> Thus changing H ⟨Ĥ⟩ ⟨Ĥ⟩ relative to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is cheating
>>>>>>>>>>> and this
>>>>>>>>>>> exact same cheat can be used to enable H ⟨Ĥ⟩ ⟨Ĥ⟩ to get the
>>>>>>>>>>> correct
>>>>>>>>>>> answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, the problem definition requires that you write a program H
>>>>>>>>>> which correctly answers whether the direct execution of x(y)
>>>>>>>>>> halts.
>>>>>>>>>>
>>>>>>>>>> Why do you think that asking what a different halt decider
>>>>>>>>>> would write is cheating?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You have given up your side of the honest dialogue because
>>>>>>>>> you know that I am correct and have proved my point.
>>>>>>>>
>>>>>>>> You can't answer because you know that you are not correct. You
>>>>>>>> can't explain what cheating is because you know that you make no
>>>>>>>> sense.
>>>>>>>>
>>>>>>>
>>>>>>> As I already said: If H is is allowed to cheat the way that you and
>>>>>>> Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the
>>>>>>> halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct
>>>>>>> answer.
>>>>>>
>>>>>> What is cheating?
>>>>>>
>>>>>
>>>>> As I already said: If H is is allowed to cheat the way that you and
>>>>> Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then
>>>>
>>>> WHAT IS CHEATING?
>>>>
>>>
>>> Read it this time:
>>> *As I already said: If H is is allowed to cheat the way that you and*
>>> *Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
>>> *halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.
>>
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>>
>>>
>>> Read it this time:
>>> *As I already said: If H is is allowed to cheat the way that you and*
>>> *Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
>>> *halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.
>>
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>>
>>> Read it this time:
>>> *As I already said: If H is is allowed to cheat the way that you and*
>>> *Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
>>> *halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.
>>
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>>
>>> Read it this time:
>>> *As I already said: If H is is allowed to cheat the way that you and*
>>> *Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
>>> *halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.
>>
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>> Read it this time:
>> WHAT IS CHEATING?
>
> In other words you forgot your own words that I refer to?
> Every H must have identical behavior, You and Mike proposed otherwise.
> That is cheating.

Every identical program must have identical behaviour. If you change one
program called H and don't change another, they are not identical
programs and they might not have identical behaviour. Everyone except
from you insists on using different names for different programs. You
are the one who tries to call a lot of different programs H.

>
>>
>>>>>
>>>>> the halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct
>>>>> answer.
>>>>>
>>>>>
>>>>>> When I accused you of cheating it was because you talk about a
>>>>>> problem that is not related to the halting problem.
>>>>>>
>>>>>> When you accuse me of cheating what are you saying?
>>>>>>
>>>>>> Every H and D is different and multiple people have called you out
>>>>>> for confusing things by giving them all the same name. They should
>>>>>> be given different names to avoid any confusion. Although we know
>>>>>> that Ĥ1.H1 ⟨Ĥ1⟩ ⟨Ĥ1⟩ gives the incorrect answer, just like H1 ⟨Ĥ1⟩
>>>>>> ⟨Ĥ1⟩, it is possible that Ĥ2.H2 ⟨Ĥ1⟩ ⟨Ĥ1⟩ and H2 ⟨Ĥ1⟩ ⟨Ĥ1⟩ may
>>>>>> give the correct answer.
>>>>>>
>>>>>>>>>> Let D be the program you wrote in x86utm. D(D) does halt, and
>>>>>>>>>> some halt deciders recognize this. The one which D calls does
>>>>>>>>>> not recognize it, but some others do. Here's the simplest:
>>>>>>>>>>
>>>>>>>>>> bool DoesHalt(finite_string program, finite_string input) {
>>>>>>>>>>      return true;
>>>>>>>>>> }
>>>>>>
>>>>>
>>>>
>>>
>>
>

On 23/03/24 14:45, olcott wrote:
> On 3/23/2024 2:22 AM, immibis wrote:
>> On 23/03/24 02:31, olcott wrote:
>>> On 3/22/2024 7:44 PM, immibis wrote:
>>>> On 22/03/24 22:22, olcott wrote:
>>>>> On 3/22/2024 4:17 PM, immibis wrote:
>>>>>> On 22/03/24 22:01, olcott wrote:
>>>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>>>> On 22/03/24 20:49, olcott wrote:
>>>>>>>>> The false assumption that a halt decider must report on behavior
>>>>>>>>> that is different than the behavior that it actually sees.
>>>>>>>>>
>>>>>>>> That is a true assumption. That is the specification of a halt
>>>>>>>> decider. It must report whether a program would ever halt even
>>>>>>>> though it cannot see whether a program would ever halt.
>>>>>>>
>>>>>>> That contradicts the correct definition of a decider that
>>>>>>> must compute the mapping from its input on the basis of a
>>>>>>> (in this case semantic) property of this input.
>>>>>>
>>>>>> It does not contradict.
>>>>>>
>>>>>>> Since D does specify non-halting behavior to H then H(D,D)
>>>>>>> is necessarily correct to reject this input as non-halting.
>>>>>>
>>>>>> D specifies a program which halts when executed.
>>>>>
>>>>> That the simulation of D must be aborted by H to prevent its own
>>>>> infinite execution
>>>>
>>>> You think this phrase means something different to what everyone
>>>> else thinks it means. Therefore I recommend not using it.
>>>>
>>>
>>> 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...
>>>
>> How is that a rebuttal to what I said?
>
> If you can't tell then you aren't honest.
>
If you can't tell me then you aren't honest.

On 3/23/2024 5:59 PM, immibis wrote:
> On 23/03/24 15:41, olcott wrote:
>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>> Right, and since D,D specifies the program D(D) and that Halts,
>>
>> Since you know that D(D) correctly simulated by H cannot
>> possibly halt, why lie about this and use the strawman
>> deception to refer to an instance of D(D) that does not
>> even exist in the above computation?
>>
> The halting problem is about whether a program halts not whether a
> "correct simulation" of that program halts.

The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.

*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.

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

On 3/23/24 7:23 PM, olcott wrote:
> On 3/23/2024 5:59 PM, immibis wrote:
>> On 23/03/24 15:41, olcott wrote:
>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>
>>> Since you know that D(D) correctly simulated by H cannot
>>> possibly halt, why lie about this and use the strawman
>>> deception to refer to an instance of D(D) that does not
>>> even exist in the above computation?
>>>
>> The halting problem is about whether a program halts not whether a
>> "correct simulation" of that program halts.
>
> The halting problem is about computing the mapping from the inputs
> to an accept or reject state on the basis of the behavior that the
> input specifies.
>
> *The input to H(D,D) specifies non-halting behavior to H*
> The above are self-evidently true facts and cannot be denied
> without error.
>

No, it doesn't.

It specified the behavior of RUNNING D(D). This is an OBJECTIVE specficatin

It is up to H to figure out how to determine that behavior, which is
independent of who is looking or how they looking.

The fact that you THINK that D(D) presents non-halting behavior to D,
when it is in fact Halting, just proves that you have absolutely no idea
what you are talking about, and havve just been lying the whole time.

On 3/23/24 5:08 PM, olcott wrote:
> On 3/23/2024 4:02 PM, Richard Damon wrote:
>> On 3/23/24 3:25 PM, olcott wrote:
>>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>>
>>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he
>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are
>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>>>>> agreement
>>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I admitted that I was wrong about the details of some
>>>>>>>>>>>>>>> things:
>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>>>>>>>>>>
>>>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning or
>>>>>>>>>>>> rhetoric.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>>
>>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>>>>> reasoning"
>>>>>>>>>> do count as rhetoric.
>>>>>>>>>>
>>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning basis.
>>>>>>>>> I am correct when I do this.
>>>>>>>>
>>>>>>>> You usually don't. Moreoften you produce fake "rebuttals" that lack
>>>>>>>> any correct reasoning basis.
>>>>>>>>
>>>>>>>
>>>>>>> *So far no one has actually shown that*
>>>>>>
>>>>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>>> that everithing is sufficiently clear to most participants.
>>>>>>
>>>>>
>>>>> 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 }
>>>>>
>>>>> For the entire set of every implmentation of H where H simulates
>>>>> its input no D can possibly reach its own final state at line 06
>>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>>
>>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING*
>>>> either.
>>>> So, an aborted simulation cannot prove that an abort is required.
>>>>
>>>
>>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>>> That is merely yet another instance of the strawman deception.
>>> We never have been talking about an arbitrary aborted simulation.
>>
>> Right, H aborting its simulation doesn't make the input Non-Halting,
>> that is based on the DIRECT EXECUTION of that input exactly as it was
>> presented to H, that is, calling the H that it was originally calling.
>> (the one claimed to give the right answer)
>>
>>>
>>> We have only been talking about a simulation of D by H that cannot
>>> possibly reach its own final state at line 06 in an infinite number
>>> of steps of correct simulation.
>>
>> Then I guess you are admitting that you only H just fails to be a
>> decider, since it actually does just simulate its input for an
>> infinite number of steps.
>>
>> I guess you are done and admit defeat.
>>
>> Now, I KNOW you are just lying, because you are ACTUALLY going to say
>> that now that we have established this is what D does, H can be
>> changed to abort, but then we have to throw out that conclusion, as D
>> changes when we change H.
>>
>>
>> So, if H DOES abort its simulation then this aborting does NOT, by
>> itself make D non-halting, but we need to look at what D actually does.
>>
>> If D aborts its simulation and call the input non-halting, then D will
>> halt, and thus H was just INCORRECT to have aborted its simulation, as
>> this new behavior of D was established when we changed H, so NOW it is
>> not correct to abort its simulation
>>
>>>
>>> Everyone with sufficient programming skill can see that this is a
>>> verified fact:
>>>
>>> *D correctly simulated by H cannot possibly reach its own final state*
>>> *at line 06 in an infinite number of steps of correct simulation*
>>> Some of these people might lie about it.
>>>
>>
>> Right, so if H does correctly simulate D, then it doesn't abort and
>> fails to be a decider.
>>
>
> *Like I said some people might lie about it*
> H does correctly simulate D until it can see that every D simulated
> by any H cannot possibly halt. Then H has its correct basis to abort
> its simulation of D and reject D as non-halting.
>

On 24/03/24 00:23, olcott wrote:
> On 3/23/2024 5:59 PM, immibis wrote:
>> On 23/03/24 15:41, olcott wrote:
>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>
>>> Since you know that D(D) correctly simulated by H cannot
>>> possibly halt, why lie about this and use the strawman
>>> deception to refer to an instance of D(D) that does not
>>> even exist in the above computation?
>>>
>> The halting problem is about whether a program halts not whether a
>> "correct simulation" of that program halts.
>
> The halting problem is about computing the mapping from the inputs
> to an accept or reject state on the basis of the behavior that the
> input specifies.
>
> *The input to H(D,D) specifies non-halting behavior to H*
> The above are self-evidently true facts and cannot be denied
> without error.
>

The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and its input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input) would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input) would
never halt

On 3/23/2024 7:17 PM, Richard Damon wrote:
> On 3/23/24 7:23 PM, olcott wrote:
>> On 3/23/2024 5:59 PM, immibis wrote:
>>> On 23/03/24 15:41, olcott wrote:
>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>
>>>> Since you know that D(D) correctly simulated by H cannot
>>>> possibly halt, why lie about this and use the strawman
>>>> deception to refer to an instance of D(D) that does not
>>>> even exist in the above computation?
>>>>
>>> The halting problem is about whether a program halts not whether a
>>> "correct simulation" of that program halts.
>>
>> The halting problem is about computing the mapping from the inputs
>> to an accept or reject state on the basis of the behavior that the
>> input specifies.
>>
>> *The input to H(D,D) specifies non-halting behavior to H*
>> The above are self-evidently true facts and cannot be denied
>> without error.
>>
>
> No, it doesn't.
>
> It specified the behavior of RUNNING D(D). This is an OBJECTIVE specficatin
>

On 3/22/2024 9:17 PM, Richard Damon wrote:
>
> 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 not taking that into account*

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

On 3/23/2024 7:22 PM, Richard Damon wrote:
> On 3/23/24 5:08 PM, olcott wrote:
>> On 3/23/2024 4:02 PM, Richard Damon wrote:
>>> On 3/23/24 3:25 PM, olcott wrote:
>>>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he
>>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are
>>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>>>>>> agreement
>>>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I admitted that I was wrong about the details of some
>>>>>>>>>>>>>>>> things:
>>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *See if you can rebut this with reasoning instead of
>>>>>>>>>>>>>> rhetoric*
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>> criteria--Mikes-rebuttal--]
>>>>>>>>>>>>>
>>>>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning
>>>>>>>>>>>>> or rhetoric.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>>>
>>>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>>>>>> reasoning"
>>>>>>>>>>> do count as rhetoric.
>>>>>>>>>>>
>>>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning
>>>>>>>>>> basis.
>>>>>>>>>> I am correct when I do this.
>>>>>>>>>
>>>>>>>>> You usually don't. Moreoften you produce fake "rebuttals" that
>>>>>>>>> lack
>>>>>>>>> any correct reasoning basis.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *So far no one has actually shown that*
>>>>>>>
>>>>>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>>>> that everithing is sufficiently clear to most participants.
>>>>>>>
>>>>>>
>>>>>> 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 }
>>>>>>
>>>>>> For the entire set of every implmentation of H where H simulates
>>>>>> its input no D can possibly reach its own final state at line 06
>>>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>>>
>>>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING*
>>>>> either.
>>>>> So, an aborted simulation cannot prove that an abort is required.
>>>>>
>>>>
>>>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>>>> That is merely yet another instance of the strawman deception.
>>>> We never have been talking about an arbitrary aborted simulation.
>>>
>>> Right, H aborting its simulation doesn't make the input Non-Halting,
>>> that is based on the DIRECT EXECUTION of that input exactly as it was
>>> presented to H, that is, calling the H that it was originally
>>> calling. (the one claimed to give the right answer)
>>>
>>>>
>>>> We have only been talking about a simulation of D by H that cannot
>>>> possibly reach its own final state at line 06 in an infinite number
>>>> of steps of correct simulation.
>>>
>>> Then I guess you are admitting that you only H just fails to be a
>>> decider, since it actually does just simulate its input for an
>>> infinite number of steps.
>>>
>>> I guess you are done and admit defeat.
>>>
>>> Now, I KNOW you are just lying, because you are ACTUALLY going to say
>>> that now that we have established this is what D does, H can be
>>> changed to abort, but then we have to throw out that conclusion, as D
>>> changes when we change H.
>>>
>>>
>>> So, if H DOES abort its simulation then this aborting does NOT, by
>>> itself make D non-halting, but we need to look at what D actually does.
>>>
>>> If D aborts its simulation and call the input non-halting, then D
>>> will halt, and thus H was just INCORRECT to have aborted its
>>> simulation, as this new behavior of D was established when we changed
>>> H, so NOW it is not correct to abort its simulation
>>>
>>>>
>>>> Everyone with sufficient programming skill can see that this is a
>>>> verified fact:
>>>>
>>>> *D correctly simulated by H cannot possibly reach its own final state*
>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>> Some of these people might lie about it.
>>>>
>>>
>>> Right, so if H does correctly simulate D, then it doesn't abort and
>>> fails to be a decider.
>>>
>>
>> *Like I said some people might lie about it*
>> H does correctly simulate D until it can see that every D simulated
>> by any H cannot possibly halt. Then H has its correct basis to abort
>> its simulation of D and reject D as non-halting.
>>
>
> But that isn't the question, so it gets the wrong answer.
>
(1) It is the abort/no abort question.

On 3/23/2024 8:40 PM, immibis wrote:
> On 24/03/24 00:23, olcott wrote:
>> On 3/23/2024 5:59 PM, immibis wrote:
>>> On 23/03/24 15:41, olcott wrote:
>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>
>>>> Since you know that D(D) correctly simulated by H cannot
>>>> possibly halt, why lie about this and use the strawman
>>>> deception to refer to an instance of D(D) that does not
>>>> even exist in the above computation?
>>>>
>>> The halting problem is about whether a program halts not whether a
>>> "correct simulation" of that program halts.
>>
>> The halting problem is about computing the mapping from the inputs
>> to an accept or reject state on the basis of the behavior that the
>> input specifies.
>>
>> *The input to H(D,D) specifies non-halting behavior to H*
>> The above are self-evidently true facts and cannot be denied
>> without error.
>>
>
> The halting problem is quite simple:
> Create a program HaltCheck (or Turing machine) so that:
> * the input Prog,Input is another program (or Turing machine) and its input
> * HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input) would
> halt
> * HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input) would
> never halt

The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.

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