On 3/21/2024 10:11 PM, Richard Damon wrote:
> On 3/21/24 10:45 PM, olcott wrote:
>> On 3/21/2024 8:27 PM, immibis wrote:
>>> On 21/03/24 19:24, olcott wrote:
>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>> On 21/03/24 15:32, olcott wrote:
>>>>>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>>>>>
>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>> correct answer is NO.
>>>>>>
>>>>>>> And if H^.H (H^) (H^) says No, then the correct answer is Yes
>>>>>>
>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>> correct answer is YES.
>>>>>
>>>>> In other words you believe there are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of
>>>>> the above set which say YES or NO.
>>>>
>>>> Not at all. You did not read my words correctly.
>>>>
>>> I read them correctly.
>>
>> Every element in the above set says YES or NO, none of them
>> do this correctly because their answer is always contradicted.
>>
>
> Right, so they are all WRONG, and the WAS a correct answer, just not the
> one they gave.
>

Every element of the set of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is defined as giving the
the wrong answer because Every element of the set of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
has its answer contradicted.

*typos corrected*
Everyone honest believes that there are very simple things that
computers cannot do. They never realize that there is no theoretical
reason why computers cannot simultaneously exceed all of the best
experts in every human field of expertise by 100,000-fold.

That computers can't solve problems as easy as the Liar Paradox
gives people a false impression of the actual limits of computation.

> And you are proved to not understand the first thing about logic.

--
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/21/2024 10:43 PM, immibis wrote:
> On 21/03/24 19:31, olcott wrote:
>> On 3/21/2024 12:31 PM, immibis wrote:
>>> On 21/03/24 05:34, olcott wrote:
>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>> On 20/03/24 23:52, 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 }
>>>>>>>>
>>>>>>>
>>>>>>> Your question is meaningless.
>>>>>>>
>>>>>>
>>>>>> Software engineering forums disagree.
>>>>>>
>>>>> Then they are stupid. Obviously this question cannot be answered
>>>>> without seeing the exact code of H, and then there is also the
>>>>> question about what "correctly simulated" and "terminate normally"
>>>>> mean.
>>>>
>>>> The code is available.
>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>
>>>> It Simulates according to the c source code.
>>>> Few people understand x86 assembly langugae.
>>>
>>> You cheat the halting problem because D is not a complete program, it
>>> can specify anything and everything, including making mashed potatoes.
>>
>> D is precisely isomorphic to the Strachey P.
>> https://academic.oup.com/comjnl/article/7/4/313/354243
>
> The Strachey P is a very short illustration of the problem which does
> not explain the details. It gets the main point across in a very short
> space, but only the main point and not the details. Because it does not
> explain the details it cannot be relied on to be correct in detail.

On 22/03/24 04:46, olcott wrote:
> On 3/21/2024 10:11 PM, Richard Damon wrote:
>> On 3/21/24 10:45 PM, olcott wrote:
>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>> On 21/03/24 19:24, olcott wrote:
>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>> On 21/03/24 15:32, olcott wrote:
>>>>>>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>>>>>>
>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>> correct answer is NO.
>>>>>>>
>>>>>>>> And if H^.H (H^) (H^) says No, then the correct answer is Yes
>>>>>>>
>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>> correct answer is YES.
>>>>>>
>>>>>> In other words you believe there are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of
>>>>>> the above set which say YES or NO.
>>>>>
>>>>> Not at all. You did not read my words correctly.
>>>>>
>>>> I read them correctly.
>>>
>>> Every element in the above set says YES or NO, none of them
>>> do this correctly because their answer is always contradicted.
>>>
>>
>> Right, so they are all WRONG, and the WAS a correct answer, just not
>> the one they gave.
>>
>
> Every element of the set of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is defined as giving the
> the wrong answer

No, not defined. It just does give the wrong answer.

> because Every element of the set of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> has its answer contradicted.
>
> *typos corrected*
> Everyone honest believes that there are very simple things that
> computers cannot do.

Everyone believed it would be simple to make a computer program that
would tell whether programs halt and make this program correct in all
cases, yes.

> They never realize that there is no theoretical
> reason why computers cannot simultaneously exceed all of the best
> experts in every human field of expertise by 100,000-fold.

Most people except for you now understand it is not possible to make a
computer program that would tell whether programs halt and make this
program correct in all cases.

> That computers can't solve problems as easy as the Liar Paradox
> gives people a false impression of the actual limits of computation.

Nobody knew the halting problem was related to the liar paradox until it
was proven.

>> And you are proved to not understand the first thing about logic.

On 3/21/2024 10:11 PM, Richard Damon wrote:
> On 3/21/24 10:32 AM, olcott wrote:
>> On 3/21/2024 6:39 AM, Richard Damon wrote:
>>> On 3/20/24 11:55 PM, olcott wrote:
>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>> On 20/03/24 23:50, olcott wrote:
>>>>>> On 3/20/2024 5:40 PM, immibis wrote:
>>>>>>> On 20/03/24 22:49, olcott wrote:
>>>>>>>> On 3/20/2024 4:42 PM, Richard Damon wrote:
>>>>>>>>> On 3/19/24 2:15 PM, olcott wrote:
>>>>>>>>>> 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 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>
>>>>>>>>> How is that.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then
>>>>>>>> halts.
>>>>>>>>
>>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>>>>>>>>
>>>>>>>
>>>>>>> Those are different Ĥ.
>>>>>>
>>>>>> The question is always: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>
>>>>> This is an infinite set of questions if Ĥ is an infinite set of
>>>>> programs. Which one are you actually talking about?
>>>>
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ : Does Ĥ ⟨Ĥ⟩ halt?
>>>
>>>
>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>
>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the correct
>> answer is NO.
>>
>
> No, it is for ALL of them, since H^.H (H^) (H^) goes to qy, then H^ (H^)
> will go to qy and loop an H^ (H^) will be non-halting, so the correct
> answer is NO.
>
> Why do you say it isn't?

You know that every answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is contradicted
and that is the only reason that all of its answers are wrong.

--
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/21/2024 10:41 PM, immibis wrote:
> On 22/03/24 02:41, olcott wrote:
>> On 3/21/2024 8:23 PM, immibis wrote:
>>> On 22/03/24 01:29, olcott wrote:
>>>> On 3/21/2024 7:03 PM, immibis wrote:
>>>>> On 21/03/24 22:25, olcott wrote:
>>>>>> On 3/21/2024 3:54 PM, Fred. Zwarts wrote:
>>>>>>> Op 21.mrt.2024 om 21:18 schreef olcott:
>>>>>>>> On 3/21/2024 2:56 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 21.mrt.2024 om 14:55 schreef olcott:
>>>>>>>>>> On 3/21/2024 4:56 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 21.mrt.2024 om 00:08 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/20/24 6:01 PM, 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> you CAN'T do that and make D a Computation. If it isn't a
>>>>>>>>>>>>> Computation, you aren't doing anything like Computability
>>>>>>>>>>>>> Theory and NOTHING you talk about will have anything to do
>>>>>>>>>>>>> with the Halt Problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You just stipulated yourself out of your "proof"
>>>>>>>>>>>>>
>>>>>>>>>>>>> If D just "refers" to the behavior of the decider that is
>>>>>>>>>>>>> deciding it as a template, then you are going to need to
>>>>>>>>>>>>> define what that REALLY MEANS, to see if your
>>>>>>>>>>>>> OLCOTT-ABORTING is at all an interesting problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Likely not, from what I see, so you are just stipulating
>>>>>>>>>>>>> the wasting of the last 20 years, and probably the rest of
>>>>>>>>>>>>> your life.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yep, shows that H's that don't abort the D built on them
>>>>>>>>>>>>> won't be deciders, so can't even get into the chalange of
>>>>>>>>>>>>> being a Halt Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Doesn't say anything about the D built on the Hs that abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If every element of a set is defined to have a certain property
>>>>>>>>>>>> then that makes any claim that some of the elements don't have
>>>>>>>>>>>> this property a blatant lie.
>>>>>>>>>>>
>>>>>>>>>>> Exactly! So the claim that the D that is based on a H that
>>>>>>>>>>> aborts and returns does not halt is a blatant lie.
>>>>>>>>>>
>>>>>>>>>> What H(D,D) returns is out-of-scope for this post.
>>>>>>>>>> That H(D,D) must abort or fail to halt is conclusive
>>>>>>>>>> proof that H(D,D) is correct to abort its simulation.
>>>>>>>>>>
>>>>>>>>>> That anyone knowing C very well can see that H(D,D) would
>>>>>>>>>> otherwise
>>>>>>>>>> remain stuck in recursive simulation is the essence of the
>>>>>>>>>> proof that
>>>>>>>>>> H(D,D) must abort. People that can not see this are
>>>>>>>>>> unqualified to
>>>>>>>>>> evaluate my work.
>>>>>>>>>>
>>>>>>>>>> When we provide the details of exactly how H(D,D) does this
>>>>>>>>>> people
>>>>>>>>>> are either unqualified or disingenuous.
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Everybody with a few weeks of experience in programming will
>>>>>>>>> understand that if H aborts and returns false there is no
>>>>>>>>> reason to abort D.
>>>>>>>>
>>>>>>>> By this same reasoning after you have eaten lunch you don't need
>>>>>>>> to eat
>>>>>>>> lunch thus never needed to eat lunch at all.
>>>>>>>>
>>>>>>>>> When the simulating decider sees the call to H and refuses to
>>>>>>>>> simulate H, then it should take into consideration that this H
>>>>>>>>> aborts and returns false in order to decide whether D halts or
>>>>>>>>> not. If it guesses that H keeps running, it contradicts a
>>>>>>>>> verified fact.
>>>>>>>>
>>>>>>>> Because every H has the exact same machine code unless the first
>>>>>>>> H(D,D) aborts then none of them abort.
>>>>>>>
>>>>>>> If every H has the exact same machine code, then there is only
>>>>>>> one H and the word 'every' is misleading.
>>>>>>
>>>>>> That makes it all the more dishonest for people to claim that H
>>>>>> behaves
>>>>>> differently than itself.
>>>>>>
>>>>>>> The word 'unless' is also misleading,
>>>>>>
>>>>>> I was intended to mean the exact same thing as selection
>>>>>> from sequence, selection, iteration.
>>>>>>
>>>>>>> because this H aborts. Therefore, the simulated H is also
>>>>>>> programmed to abort and the simulating H should take that into
>>>>>>> consideration,
>>>>>>
>>>>>> Even if it did it would be wrong. If this H does not abort because
>>>>>> it can see that the next one would this creates an infinite chain
>>>>>> where no H ever aborts.
>>>>>>
>>>>>>> otherwise the simulating H is just wrong. The simulating H cannot
>>>>>>> assume that the simulated H is another H that keeps running,
>>>>>>> because every H has the exact same machine code, therefore a H
>>>>>>> that keeps running does not exist and should be considered.
>>>>>>
>>>>>> I don't understand how no one here understands a simple "if"
>>>>>> statement.
>>>>>>
>>>>>
>>>>> https://en.wikipedia.org/wiki/Quantifier_shift
>>>>>
>>>>> Because every sibling has the exact same mother unless Peter has a
>>>>> blue-eyed mother then every person has a blue-eyed mother. - olcott
>>>>
>>>>
>>>> Can D correctly simulated by H terminate normally?
>>>
>>> Underspecified question. Can the dog correctly wearing a leash bark?
>>>
>>
>> D correctly simulated by and H cannot possibly reach its
>> own final state and halt. Software engineers understand
>> this as terminating 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 implementation of H must abort its simulation or
>>>> itself never stops running.
>>>
>>> Actually D will crash as soon as it reaches line 03 because the
>>> function H is not defined.
>>
>> You didn't bother to read this:
>>
>> Every implementation of H
>> Every implementation of H
>> Every implementation of H
>>
>> must abort its simulation or
>> must abort its simulation or
>> must abort its simulation or
>>
>> itself never stops running.
>> itself never stops running.
>> itself never stops running.
>
> No, they can just keep simulating until it crashes. The simulation will
> stop running when the simulated code crashes.
>

On 3/21/2024 10:11 PM, Richard Damon wrote:
> On 3/21/24 10:15 AM, olcott wrote:
>> On 3/21/2024 4:43 AM, Mikko wrote:
>>> On 2024-03-20 16:11:58 +0000, olcott said:
>>>
>>>> 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*
>>>> *That would cause D(D) to loop, thus wrong answer*
>>>> *That would cause D(D) to loop, thus wrong answer*
>>>
>>> That the "yes" answer is correct does not cause D(D)
>>> to loop as long as H(D,D) does not give that answer.
>>>
>>
>> It is correct for H(D,D) to abort its simulation and everyone here can
>> look at the code and verify that they can see that unless H(D,D) does
>> abort its simulation that itself never halts.
>>
>> H knows this the same way that you do.
>> When I say how H knows this people get all counter-factual.
>>
>> 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 }
>>
>
> Nope,
>
>
> Provven elsewhere.
>
> The D built uses an H that aborts halts, so H doesn't HAVE to abort its
> simulation, but does anyway.
>

You are a Jackass.

> To look at the D usng a different H is like calling a cat a 10 story
> office building.

--
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/21/2024 10:52 PM, immibis wrote:
> On 22/03/24 04:46, olcott wrote:
>> On 3/21/2024 10:11 PM, Richard Damon wrote:
>>> On 3/21/24 10:45 PM, olcott wrote:
>>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>>> On 21/03/24 19:24, olcott wrote:
>>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>>> On 21/03/24 15:32, olcott wrote:
>>>>>>>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>>>>>>>
>>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>>> correct answer is NO.
>>>>>>>>
>>>>>>>>> And if H^.H (H^) (H^) says No, then the correct answer is Yes
>>>>>>>>
>>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>>> correct answer is YES.
>>>>>>>
>>>>>>> In other words you believe there are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of
>>>>>>> the above set which say YES or NO.
>>>>>>
>>>>>> Not at all. You did not read my words correctly.
>>>>>>
>>>>> I read them correctly.
>>>>
>>>> Every element in the above set says YES or NO, none of them
>>>> do this correctly because their answer is always contradicted.
>>>>
>>>
>>> Right, so they are all WRONG, and the WAS a correct answer, just not
>>> the one they gave.
>>>
>>
>> Every element of the set of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is defined as giving the
>> the wrong answer
>
> No, not defined. It just does give the wrong answer.
>
>> because Every element of the set of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> has its answer contradicted.
>>
>> *typos corrected*
>> Everyone honest believes that there are very simple things that
>> computers cannot do.
>
> Everyone believed it would be simple to make a computer program that
> would tell whether programs halt and make this program correct in all
> cases, yes.
>
>> They never realize that there is no theoretical
>> reason why computers cannot simultaneously exceed all of the best
>> experts in every human field of expertise by 100,000-fold.
>
> Most people except for you now understand it is not possible to make a
> computer program that would tell whether programs halt and make this
> program correct in all cases.
>

It would simply break out of the Boolean answer phase and explain all
of the details of how it is being cheated. It would then completely
reformulate the philosophical foundation of computation such that
cheating is no longer possible.

>> That computers can't solve problems as easy as the Liar Paradox
>> gives people a false impression of the actual limits of computation.
>
> Nobody knew the halting problem was related to the liar paradox until it
> was proven.
>
>>> And you are proved to not understand the first thing about logic.
>
>
>

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

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

--
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/21/2024 10:39 PM, immibis wrote:
> On 22/03/24 02:49, olcott wrote:
>> On 3/21/2024 8:27 PM, immibis wrote:
>>> On 21/03/24 19:23, olcott wrote:
>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>> On 21/03/24 15:21, olcott wrote:
>>>>>> On 3/21/2024 5:16 AM, Mikko wrote:
>>>>>>> On 2024-03-20 17:42:44 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>>>>>> On 3/20/24 9:09 AM, olcott wrote:
>>>>>>>>>> On 3/20/2024 3:43 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-19 17:54:00 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly
>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly determines
>>>>>>>>>>>>>>>>>>>>>> that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY
>>>>>>>>>>>>>>>>>>>>> CORRECTLY DETERMINES that its D will never stop
>>>>>>>>>>>>>>>>>>>>> running, unless THIS H aborts it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You never seemed to get the idea that X is a member
>>>>>>>>>>>>>>>>>>>> of set Y
>>>>>>>>>>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That seems to be your problem, you are listing TWO
>>>>>>>>>>>>>>>>>>> distinct sets, which hae two distinct set of Deciders
>>>>>>>>>>>>>>>>>>> and two distince to of inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You can't argue about an input built on a different
>>>>>>>>>>>>>>>>>>> decider tells you anything about the input built on
>>>>>>>>>>>>>>>>>>> THIS decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to
>>>>>>>>>>>>>>>>>> abort its simulation
>>>>>>>>>>>>>>>>>> to prevent D(D) from infinite execution that this
>>>>>>>>>>>>>>>>>> proves that it never
>>>>>>>>>>>>>>>>>> needed to abort its simulation because it can rely on
>>>>>>>>>>>>>>>>>> the fact that it
>>>>>>>>>>>>>>>>>> already aborted its simulation thus never needed to
>>>>>>>>>>>>>>>>>> abort it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Use of double quantifiers may be a little confusing as
>>>>>>>>>>>>>>> each D calls
>>>>>>>>>>>>>>> only one H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Counter factual*
>>>>>>>>>>>>>> My syntax is intended to specify the universe of H/D pairs
>>>>>>>>>>>>>> such that
>>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then you should quantify over those pairs with a simgle
>>>>>>>>>>>>> quantifier.
>>>>>>>>>>>>>
>>>>>>>>>>>> That wold not allow H and D to vary independently.
>>>>>>>>>>>
>>>>>>>>>>> Because the first thing after the quantifiers is to remove this
>>>>>>>>>>> independency there is no need to allow it.
>>>>>>>>>>>
>>>>>>>>>>>>> Anyway, every pair has a different D.
>>>>>>>>>>>>
>>>>>>>>>>>> *I proved otherwise below*
>>>>>>>>>>>> In infinite number of different H
>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>> all operate on the exact same D.
>>>>>>>>>>>
>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>
>>>>>>>>>>>> In infinite number of different D
>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>> are all input to the exact same H.
>>>>>>>>>>>
>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>
>>>>>>>>>>>>>> That there can be multiple H for every unique D and
>>>>>>>>>>>>>> multiple D for
>>>>>>>>>>>>>> every unique H becomes more obvious when understand that
>>>>>>>>>>>>>> we can pad
>>>>>>>>>>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>>>>>>>>>>
>>>>>>>>>>> There can be multiple D for every H because D is a parameter
>>>>>>>>>>> to H.
>>>>>>>>>>> There cannot be multiple H for any D because H is not a
>>>>>>>>>>> parameter
>>>>>>>>>>> to D and only one H is included in D.
>>>>>>>>>>>
>>>>>>>>>>> Because the
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> For every combination of H/D pairs such that
>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>> There can be
>>>>>>>>>> multiple finite strings of machine-code of D for a single H
>>>>>>>>>> and
>>>>>>>>>> multiple finite strings of machine-code of H for a single D.
>>>>>>>>>> The differences may simply be a different number of NOP padding.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, a given D might "call" any of a number of different (but
>>>>>>>>> are EQUIVALENT) Hs. But no "H" that isn't EQUIVALENT to those
>>>>>>>>> (Equivalent means gives the exact same output for the exact
>>>>>>>>> same inputs)
>>>>>>>>>
>>>>>>>>> But your wildly different Hs that your first select over give
>>>>>>>>> many different equivalency classes, and a given D only is
>>>>>>>>> paired with one.
>>>>>>>>
>>>>>>>> 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 }
>>>>>>>>
>>>>>>>> *That you already know that no D simulated by any H can possibly*
>>>>>>>> *reach its own line 06 in any finite number of steps of correct*
>>>>>>>> *simulation proves that you know that I am correct*
>>>>>>>>
>>>>>>>> That you keep trying to change the subject to a different instance
>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>
>>>>>>> That you keep trying to change the subject to a different instance
>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>
>>>>>>
>>>>>> Every element of the infinite set of H/D pairs has the same semantic
>>>>>> property and the differences between elements is totally irrelevant
>>>>>> to this shared semantic property.
>>>>>>
>>>>>> It is the case that every element of the set of H/D pairs where H
>>>>>> simulates its input is correct when it determines to abort this
>>>>>> simulation otherwise itself would never stop running.
>>>>>>
>>>>>>
>>>>>
>>>>> Semantic properties are irrelevant to actual behaviour.
>>>>
>>>> The actual behavior is the behavior of N steps of D(D) correctly
>>>> simulated by H(D,D).
>>>
>>> Where N is the number of steps until it halts.
>>>
>>>> The actual behavior of D(D) is not the same as N steps of D(D)
>>>> correctly simulated by H(D,D).
>>>
>>> You literally just said it was.
>>>
>>
>> The actual behavior of [THE DIRECTLY EXECUTED] D(D) is not
>> the same as N steps of D(D) correctly simulated by H(D,D).
>
> The actual behaviour of the directly executed X(Y) is the same as the
> actual behaviour of X(Y) correctly simulated by any correct simulator OR
> ELSE IT IS NOT A CORRECT SIMULATOR.

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?

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 22/03/24 04:55, olcott wrote:
> On 3/21/2024 10:41 PM, immibis wrote:
>> On 22/03/24 02:41, olcott wrote:
>>> On 3/21/2024 8:23 PM, immibis wrote:
>>>> On 22/03/24 01:29, olcott wrote:
>>>>> On 3/21/2024 7:03 PM, immibis wrote:
>>>>>> On 21/03/24 22:25, olcott wrote:
>>>>>>> On 3/21/2024 3:54 PM, Fred. Zwarts wrote:
>>>>>>>> Op 21.mrt.2024 om 21:18 schreef olcott:
>>>>>>>>> On 3/21/2024 2:56 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 21.mrt.2024 om 14:55 schreef olcott:
>>>>>>>>>>> On 3/21/2024 4:56 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 21.mrt.2024 om 00:08 schreef olcott:
>>>>>>>>>>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/20/24 6:01 PM, 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> you CAN'T do that and make D a Computation. If it isn't a
>>>>>>>>>>>>>> Computation, you aren't doing anything like Computability
>>>>>>>>>>>>>> Theory and NOTHING you talk about will have anything to do
>>>>>>>>>>>>>> with the Halt Problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You just stipulated yourself out of your "proof"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If D just "refers" to the behavior of the decider that is
>>>>>>>>>>>>>> deciding it as a template, then you are going to need to
>>>>>>>>>>>>>> define what that REALLY MEANS, to see if your
>>>>>>>>>>>>>> OLCOTT-ABORTING is at all an interesting problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Likely not, from what I see, so you are just stipulating
>>>>>>>>>>>>>> the wasting of the last 20 years, and probably the rest of
>>>>>>>>>>>>>> your life.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yep, shows that H's that don't abort the D built on them
>>>>>>>>>>>>>> won't be deciders, so can't even get into the chalange of
>>>>>>>>>>>>>> being a Halt Decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Doesn't say anything about the D built on the Hs that abort.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If every element of a set is defined to have a certain
>>>>>>>>>>>>> property
>>>>>>>>>>>>> then that makes any claim that some of the elements don't have
>>>>>>>>>>>>> this property a blatant lie.
>>>>>>>>>>>>
>>>>>>>>>>>> Exactly! So the claim that the D that is based on a H that
>>>>>>>>>>>> aborts and returns does not halt is a blatant lie.
>>>>>>>>>>>
>>>>>>>>>>> What H(D,D) returns is out-of-scope for this post.
>>>>>>>>>>> That H(D,D) must abort or fail to halt is conclusive
>>>>>>>>>>> proof that H(D,D) is correct to abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>> That anyone knowing C very well can see that H(D,D) would
>>>>>>>>>>> otherwise
>>>>>>>>>>> remain stuck in recursive simulation is the essence of the
>>>>>>>>>>> proof that
>>>>>>>>>>> H(D,D) must abort. People that can not see this are
>>>>>>>>>>> unqualified to
>>>>>>>>>>> evaluate my work.
>>>>>>>>>>>
>>>>>>>>>>> When we provide the details of exactly how H(D,D) does this
>>>>>>>>>>> people
>>>>>>>>>>> are either unqualified or disingenuous.
>>>>>>>>>>>
>>>>>>>>>>> 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 }
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Everybody with a few weeks of experience in programming will
>>>>>>>>>> understand that if H aborts and returns false there is no
>>>>>>>>>> reason to abort D.
>>>>>>>>>
>>>>>>>>> By this same reasoning after you have eaten lunch you don't
>>>>>>>>> need to eat
>>>>>>>>> lunch thus never needed to eat lunch at all.
>>>>>>>>>
>>>>>>>>>> When the simulating decider sees the call to H and refuses to
>>>>>>>>>> simulate H, then it should take into consideration that this H
>>>>>>>>>> aborts and returns false in order to decide whether D halts or
>>>>>>>>>> not. If it guesses that H keeps running, it contradicts a
>>>>>>>>>> verified fact.
>>>>>>>>>
>>>>>>>>> Because every H has the exact same machine code unless the first
>>>>>>>>> H(D,D) aborts then none of them abort.
>>>>>>>>
>>>>>>>> If every H has the exact same machine code, then there is only
>>>>>>>> one H and the word 'every' is misleading.
>>>>>>>
>>>>>>> That makes it all the more dishonest for people to claim that H
>>>>>>> behaves
>>>>>>> differently than itself.
>>>>>>>
>>>>>>>> The word 'unless' is also misleading,
>>>>>>>
>>>>>>> I was intended to mean the exact same thing as selection
>>>>>>> from sequence, selection, iteration.
>>>>>>>
>>>>>>>> because this H aborts. Therefore, the simulated H is also
>>>>>>>> programmed to abort and the simulating H should take that into
>>>>>>>> consideration,
>>>>>>>
>>>>>>> Even if it did it would be wrong. If this H does not abort because
>>>>>>> it can see that the next one would this creates an infinite chain
>>>>>>> where no H ever aborts.
>>>>>>>
>>>>>>>> otherwise the simulating H is just wrong. The simulating H
>>>>>>>> cannot assume that the simulated H is another H that keeps
>>>>>>>> running, because every H has the exact same machine code,
>>>>>>>> therefore a H that keeps running does not exist and should be
>>>>>>>> considered.
>>>>>>>
>>>>>>> I don't understand how no one here understands a simple "if"
>>>>>>> statement.
>>>>>>>
>>>>>>
>>>>>> https://en.wikipedia.org/wiki/Quantifier_shift
>>>>>>
>>>>>> Because every sibling has the exact same mother unless Peter has a
>>>>>> blue-eyed mother then every person has a blue-eyed mother. - olcott
>>>>>
>>>>>
>>>>> Can D correctly simulated by H terminate normally?
>>>>
>>>> Underspecified question. Can the dog correctly wearing a leash bark?
>>>>
>>>
>>> D correctly simulated by and H cannot possibly reach its
>>> own final state and halt. Software engineers understand
>>> this as terminating 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 implementation of H must abort its simulation or
>>>>> itself never stops running.
>>>>
>>>> Actually D will crash as soon as it reaches line 03 because the
>>>> function H is not defined.
>>>
>>> You didn't bother to read this:
>>>
>>> Every implementation of H
>>> Every implementation of H
>>> Every implementation of H
>>>
>>> must abort its simulation or
>>> must abort its simulation or
>>> must abort its simulation or
>>>
>>> itself never stops running.
>>> itself never stops running.
>>> itself never stops running.
>>
>> No, they can just keep simulating until it crashes. The simulation
>> will stop running when the simulated code crashes.
>>
>
> The purpose of the C code is to extrapolate what an isomorphic
> machine would do if it had unlimited memory. It would have no
> reason to crash.

On 22/03/24 04:50, olcott wrote:
> On 3/21/2024 10:43 PM, immibis wrote:
>> On 21/03/24 19:31, olcott wrote:
>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>> On 21/03/24 05:34, olcott wrote:
>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>>> On 20/03/24 23:52, 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 }
>>>>>>>>>
>>>>>>>>
>>>>>>>> Your question is meaningless.
>>>>>>>>
>>>>>>>
>>>>>>> Software engineering forums disagree.
>>>>>>>
>>>>>> Then they are stupid. Obviously this question cannot be answered
>>>>>> without seeing the exact code of H, and then there is also the
>>>>>> question about what "correctly simulated" and "terminate normally"
>>>>>> mean.
>>>>>
>>>>> The code is available.
>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>
>>>>> It Simulates according to the c source code.
>>>>> Few people understand x86 assembly langugae.
>>>>
>>>> You cheat the halting problem because D is not a complete program,
>>>> it can specify anything and everything, including making mashed
>>>> potatoes.
>>>
>>> D is precisely isomorphic to the Strachey P.
>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>
>> The Strachey P is a very short illustration of the problem which does
>> not explain the details. It gets the main point across in a very short
>> space, but only the main point and not the details. Because it does
>> not explain the details it cannot be relied on to be correct in detail.
>
> The only relevant detail is the same as my H(D,D) != Halts(D,D)
> because every return value is contradicted.
>
In other words, every return value is wrong.

On 3/21/2024 10:10 PM, Richard Damon wrote:
> On 3/21/24 10:27 AM, olcott wrote:
>> On 3/21/2024 6:37 AM, Richard Damon wrote:
>>> On 3/20/24 11:47 PM, olcott wrote:
>>>> On 3/20/2024 9:41 PM, Richard Damon wrote:
>>>>> On 3/20/24 10:18 PM, olcott wrote:
>>>>>> On 3/20/2024 9:13 PM, Richard Damon wrote:
>>>>>>> On 3/20/24 7:38 PM, olcott wrote:
>>>>>>>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>>>>>>>> On 3/20/24 6:52 PM, olcott wrote:
>>>>>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the
>>>>>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct
>>>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be
>>>>>>>>>>>>>>>>>>>>>>>> redefined.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting
>>>>>>>>>>>>>>>>>>>>>>> Question.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second
>>>>>>>>>>>>>>>>>>>>>> entity.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would be correct for this D. We can build another D,
>>>>>>>>>>>>>>> based on the new H, but then the question changes,
>>>>>>>>>>>>>>> because the input changes. The new H does not give the
>>>>>>>>>>>>>>> correct answer for the new D.
>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>> input changes. The new H does not give the correct answer
>>>>>>>>>>>>>>> for the new D.
>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>> input changes. The new H does not give the correct answer
>>>>>>>>>>>>>>> for the new D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>> corresponding H failed to give it. It seems Olcott is
>>>>>>>>>>>>>>> again confused, because he uses the same names for
>>>>>>>>>>>>>>> different things.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Referring to a different D then the one you were given is a
>>>>>>>>>>>>> very lame attempt to get away with a strawman deception.
>>>>>>>>>>>>
>>>>>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>>>>>> implementations of H.
>>>>>>>>>>>
>>>>>>>>>>> If you are still talking about the Linz proof instead of some
>>>>>>>>>>> bullshit, every D is based on exactly one H. If you change H
>>>>>>>>>>> but don't change D, the D is still based on the old H and the
>>>>>>>>>>> correct answer to the question "Does D(D) halt?" does not
>>>>>>>>>>> change.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> If you want to construe this as an infinite set of H/D pairs
>>>>>>>>>> where you
>>>>>>>>>> are construing that each D is somehow different this makes no
>>>>>>>>>> difference
>>>>>>>>>> at all.
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that doesn't abort its simulated input never
>>>>>>>>>> stops running.
>>>>>>>>>> Every H(D,D) that doesn't abort its simulated input never
>>>>>>>>>> stops running.
>>>>>>>>>> Every H(D,D) that doesn't abort its simulated input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which STILL doesn't say what happens to the D's built on the Hs
>>>>>>>>> that DO Abort.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *All of them are on the correct side of the abort/no abort
>>>>>>>> decision*
>>>>>>>
>>>>>>> Then why do they get the wrong answer?
>>>>>>
>>>>>> Are you trying to get away with contradicting yourself?
>>>>>>
>>>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>>>  > On 3/20/24 6:01 PM, olcott wrote:
>>>>>>  >> Every H(D,D) that doesn't abort its simulated input
>>>>>>  >> never stops running.
>>>>>>  >
>>>>>>  > Yep, shows that H's that don't abort the D built on
>>>>>>  > them won't be deciders...
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> Nothing contradictory about that.
>>>>>
>>>>> You have two distinct classes of H, that make DIFFERENT errors due
>>>>> to different behaviors they create.
>>>>>
>>>>> Those whose programming make them never abort create a D that will
>>>>> never halt, because its H get stuck in an infinite simulation loop,
>>>>> the the top level H also gets stuck in. It NEEDS to abort, but doesn't
>>>>>
>>>>> Then you have those H whose programming makes themselves abort,
>>>>> that create a D that calls an H that also aborts its simulation
>>>>
>>>> Finally the right insertion point for these words. V3
>>>> So you don't understand that when the executed H does not abort that
>>>> none of them do because they are all the exact same code?
>>>
>>>
>>> IF H is defined to not abort its simulation, then H will fail to be a
>>> decider.
>>>
>>
>>  >>>that create a D that calls an H that also aborts its simulation <<<
>> No this is incorrect.
>>
>> Unless the outermost H(D,D) aborts its simulation none of them
>> ever abort their simulation because they are all the exact same
>> machine-code.
>>
>>
>
> Right, and that H fails to be a decider.
>
> But if H does abort it simulation, then the fact that the other
> instances

On 3/21/2024 11:20 PM, immibis wrote:
> On 22/03/24 04:50, olcott wrote:
>> On 3/21/2024 10:43 PM, immibis wrote:
>>> On 21/03/24 19:31, olcott wrote:
>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>> On 21/03/24 05:34, olcott wrote:
>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>>>> On 20/03/24 23:52, 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 }
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Your question is meaningless.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Software engineering forums disagree.
>>>>>>>>
>>>>>>> Then they are stupid. Obviously this question cannot be answered
>>>>>>> without seeing the exact code of H, and then there is also the
>>>>>>> question about what "correctly simulated" and "terminate
>>>>>>> normally" mean.
>>>>>>
>>>>>> The code is available.
>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>
>>>>>> It Simulates according to the c source code.
>>>>>> Few people understand x86 assembly langugae.
>>>>>
>>>>> You cheat the halting problem because D is not a complete program,
>>>>> it can specify anything and everything, including making mashed
>>>>> potatoes.
>>>>
>>>> D is precisely isomorphic to the Strachey P.
>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>
>>> The Strachey P is a very short illustration of the problem which does
>>> not explain the details. It gets the main point across in a very
>>> short space, but only the main point and not the details. Because it
>>> does not explain the details it cannot be relied on to be correct in
>>> detail.
>>
>> The only relevant detail is the same as my H(D,D) != Halts(D,D)
>> because every return value is contradicted.
>>
> In other words, every return value is wrong.

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

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

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

On 22/03/24 05:27, olcott wrote:
> On 3/21/2024 10:10 PM, Richard Damon wrote:
>> On 3/21/24 10:27 AM, olcott wrote:
>>> On 3/21/2024 6:37 AM, Richard Damon wrote:
>>>> On 3/20/24 11:47 PM, olcott wrote:
>>>>> On 3/20/2024 9:41 PM, Richard Damon wrote:
>>>>>> On 3/20/24 10:18 PM, olcott wrote:
>>>>>>> On 3/20/2024 9:13 PM, Richard Damon wrote:
>>>>>>>> On 3/20/24 7:38 PM, olcott wrote:
>>>>>>>>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>>>>>>>>> On 3/20/24 6:52 PM, olcott wrote:
>>>>>>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves
>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem instead of merely solving
>>>>>>>>>>>>>>>>>>>>>>>>>> the Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct
>>>>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be
>>>>>>>>>>>>>>>>>>>>>>>>> redefined.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting
>>>>>>>>>>>>>>>>>>>>>>>> Question.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this
>>>>>>>>>>>>>>>>>>>>>>> second entity.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It would be correct for this D. We can build another D,
>>>>>>>>>>>>>>>> based on the new H, but then the question changes,
>>>>>>>>>>>>>>>> because the input changes. The new H does not give the
>>>>>>>>>>>>>>>> correct answer for the new D.
>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>>> input changes. The new H does not give the correct
>>>>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>>> input changes. The new H does not give the correct
>>>>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems Olcott is
>>>>>>>>>>>>>>>> again confused, because he uses the same names for
>>>>>>>>>>>>>>>> different things.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Referring to a different D then the one you were given is
>>>>>>>>>>>>>> a very lame attempt to get away with a strawman deception.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>>>>>>> implementations of H.
>>>>>>>>>>>>
>>>>>>>>>>>> If you are still talking about the Linz proof instead of
>>>>>>>>>>>> some bullshit, every D is based on exactly one H. If you
>>>>>>>>>>>> change H but don't change D, the D is still based on the old
>>>>>>>>>>>> H and the correct answer to the question "Does D(D) halt?"
>>>>>>>>>>>> does not change.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>> 08
>>>>>>>>>>> 09 void main()
>>>>>>>>>>> 10 {
>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>> 12 }
>>>>>>>>>>>
>>>>>>>>>>> If you want to construe this as an infinite set of H/D pairs
>>>>>>>>>>> where you
>>>>>>>>>>> are construing that each D is somehow different this makes no
>>>>>>>>>>> difference
>>>>>>>>>>> at all.
>>>>>>>>>>>
>>>>>>>>>>> Every H(D,D) that doesn't abort its simulated input never
>>>>>>>>>>> stops running.
>>>>>>>>>>> Every H(D,D) that doesn't abort its simulated input never
>>>>>>>>>>> stops running.
>>>>>>>>>>> Every H(D,D) that doesn't abort its simulated input never
>>>>>>>>>>> stops running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which STILL doesn't say what happens to the D's built on the
>>>>>>>>>> Hs that DO Abort.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *All of them are on the correct side of the abort/no abort
>>>>>>>>> decision*
>>>>>>>>
>>>>>>>> Then why do they get the wrong answer?
>>>>>>>
>>>>>>> Are you trying to get away with contradicting yourself?
>>>>>>>
>>>>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>>>>  > On 3/20/24 6:01 PM, olcott wrote:
>>>>>>>  >> Every H(D,D) that doesn't abort its simulated input
>>>>>>>  >> never stops running.
>>>>>>>  >
>>>>>>>  > Yep, shows that H's that don't abort the D built on
>>>>>>>  > them won't be deciders...
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Nothing contradictory about that.
>>>>>>
>>>>>> You have two distinct classes of H, that make DIFFERENT errors due
>>>>>> to different behaviors they create.
>>>>>>
>>>>>> Those whose programming make them never abort create a D that will
>>>>>> never halt, because its H get stuck in an infinite simulation
>>>>>> loop, the the top level H also gets stuck in. It NEEDS to abort,
>>>>>> but doesn't
>>>>>>
>>>>>> Then you have those H whose programming makes themselves abort,
>>>>>> that create a D that calls an H that also aborts its simulation
>>>>>
>>>>> Finally the right insertion point for these words. V3
>>>>> So you don't understand that when the executed H does not abort that
>>>>> none of them do because they are all the exact same code?
>>>>
>>>>
>>>> IF H is defined to not abort its simulation, then H will fail to be
>>>> a decider.
>>>>
>>>
>>>  >>>that create a D that calls an H that also aborts its simulation <<<
>>> No this is incorrect.
>>>
>>> Unless the outermost H(D,D) aborts its simulation none of them
>>> ever abort their simulation because they are all the exact same
>>> machine-code.
>>>
>>>
>>
>> Right, and that H fails to be a decider.
>>
>> But if H does abort it simulation, then the fact that the other instances
>
> Can't be the ones to abort because every H has the same machine-code
> thus the executed H cannot wait for simulated H(D,D) to abort or no H
> would ever abort. Your software engineering skill must be pretty weak.
>

On 22/03/24 05:11, olcott wrote:
> On 3/21/2024 10:39 PM, immibis wrote:
>> On 22/03/24 02:49, olcott wrote:
>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>> On 21/03/24 19:23, olcott wrote:
>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>> On 21/03/24 15:21, olcott wrote:
>>>>>>> On 3/21/2024 5:16 AM, Mikko wrote:
>>>>>>>> On 2024-03-20 17:42:44 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>>>>>>> On 3/20/24 9:09 AM, olcott wrote:
>>>>>>>>>>> On 3/20/2024 3:43 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-19 17:54:00 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly
>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly
>>>>>>>>>>>>>>>>>>>>>>> determines that its simulated D would never stop
>>>>>>>>>>>>>>>>>>>>>>> running unless aborted then
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY
>>>>>>>>>>>>>>>>>>>>>> CORRECTLY DETERMINES that its D will never stop
>>>>>>>>>>>>>>>>>>>>>> running, unless THIS H aborts it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You never seemed to get the idea that X is a member
>>>>>>>>>>>>>>>>>>>>> of set Y
>>>>>>>>>>>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That seems to be your problem, you are listing TWO
>>>>>>>>>>>>>>>>>>>> distinct sets, which hae two distinct set of
>>>>>>>>>>>>>>>>>>>> Deciders and two distince to of inputs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You can't argue about an input built on a different
>>>>>>>>>>>>>>>>>>>> decider tells you anything about the input built on
>>>>>>>>>>>>>>>>>>>> THIS decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to
>>>>>>>>>>>>>>>>>>> abort its simulation
>>>>>>>>>>>>>>>>>>> to prevent D(D) from infinite execution that this
>>>>>>>>>>>>>>>>>>> proves that it never
>>>>>>>>>>>>>>>>>>> needed to abort its simulation because it can rely on
>>>>>>>>>>>>>>>>>>> the fact that it
>>>>>>>>>>>>>>>>>>> already aborted its simulation thus never needed to
>>>>>>>>>>>>>>>>>>> abort it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Use of double quantifiers may be a little confusing as
>>>>>>>>>>>>>>>> each D calls
>>>>>>>>>>>>>>>> only one H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Counter factual*
>>>>>>>>>>>>>>> My syntax is intended to specify the universe of H/D
>>>>>>>>>>>>>>> pairs such that
>>>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then you should quantify over those pairs with a simgle
>>>>>>>>>>>>>> quantifier.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> That wold not allow H and D to vary independently.
>>>>>>>>>>>>
>>>>>>>>>>>> Because the first thing after the quantifiers is to remove this
>>>>>>>>>>>> independency there is no need to allow it.
>>>>>>>>>>>>
>>>>>>>>>>>>>> Anyway, every pair has a different D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *I proved otherwise below*
>>>>>>>>>>>>> In infinite number of different H
>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>> all operate on the exact same D.
>>>>>>>>>>>>
>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>
>>>>>>>>>>>>> In infinite number of different D
>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>> are all input to the exact same H.
>>>>>>>>>>>>
>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>
>>>>>>>>>>>>>>> That there can be multiple H for every unique D and
>>>>>>>>>>>>>>> multiple D for
>>>>>>>>>>>>>>> every unique H becomes more obvious when understand that
>>>>>>>>>>>>>>> we can pad
>>>>>>>>>>>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>>>>>>>>>>>
>>>>>>>>>>>> There can be multiple D for every H because D is a parameter
>>>>>>>>>>>> to H.
>>>>>>>>>>>> There cannot be multiple H for any D because H is not a
>>>>>>>>>>>> parameter
>>>>>>>>>>>> to D and only one H is included in D.
>>>>>>>>>>>>
>>>>>>>>>>>> Because the
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> For every combination of H/D pairs such that
>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>> There can be
>>>>>>>>>>> multiple finite strings of machine-code of D for a single H
>>>>>>>>>>> and
>>>>>>>>>>> multiple finite strings of machine-code of H for a single D.
>>>>>>>>>>> The differences may simply be a different number of NOP padding.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, a given D might "call" any of a number of different (but
>>>>>>>>>> are EQUIVALENT) Hs. But no "H" that isn't EQUIVALENT to those
>>>>>>>>>> (Equivalent means gives the exact same output for the exact
>>>>>>>>>> same inputs)
>>>>>>>>>>
>>>>>>>>>> But your wildly different Hs that your first select over give
>>>>>>>>>> many different equivalency classes, and a given D only is
>>>>>>>>>> paired with one.
>>>>>>>>>
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> *That you already know that no D simulated by any H can possibly*
>>>>>>>>> *reach its own line 06 in any finite number of steps of correct*
>>>>>>>>> *simulation proves that you know that I am correct*
>>>>>>>>>
>>>>>>>>> That you keep trying to change the subject to a different instance
>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>
>>>>>>>> That you keep trying to change the subject to a different instance
>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>
>>>>>>>
>>>>>>> Every element of the infinite set of H/D pairs has the same semantic
>>>>>>> property and the differences between elements is totally irrelevant
>>>>>>> to this shared semantic property.
>>>>>>>
>>>>>>> It is the case that every element of the set of H/D pairs where H
>>>>>>> simulates its input is correct when it determines to abort this
>>>>>>> simulation otherwise itself would never stop running.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Semantic properties are irrelevant to actual behaviour.
>>>>>
>>>>> The actual behavior is the behavior of N steps of D(D) correctly
>>>>> simulated by H(D,D).
>>>>
>>>> Where N is the number of steps until it halts.
>>>>
>>>>> The actual behavior of D(D) is not the same as N steps of D(D)
>>>>> correctly simulated by H(D,D).
>>>>
>>>> You literally just said it was.
>>>>
>>>
>>> The actual behavior of [THE DIRECTLY EXECUTED] D(D) is not
>>> the same as N steps of D(D) correctly simulated by H(D,D).
>>
>> The actual behaviour of the directly executed X(Y) is the same as the
>> actual behaviour of X(Y) correctly simulated by any correct simulator
>> OR ELSE IT IS NOT A CORRECT SIMULATOR.
>
> Every continues to say that even when the very obvious facts
> prove them wrong. No simulated H(D,D) called from a simulated
> D(D) can possibly return to this simulated D(D). Every directly
> executed H(D,D) always returns to its caller.

On 3/21/2024 10:35 PM, immibis wrote:
> On 22/03/24 03:45, olcott wrote:
>> On 3/21/2024 8:27 PM, immibis wrote:
>>> On 21/03/24 19:24, olcott wrote:
>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>> On 21/03/24 15:32, olcott wrote:
>>>>>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>>>>>
>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>> correct answer is NO.
>>>>>>
>>>>>>> And if H^.H (H^) (H^) says No, then the correct answer is Yes
>>>>>>
>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>> correct answer is YES.
>>>>>
>>>>> In other words you believe there are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of
>>>>> the above set which say YES or NO.
>>>>
>>>> Not at all. You did not read my words correctly.
>>>>
>>> I read them correctly.
>>
>> Every element in the above set says YES or NO, none of them
>> do this correctly because their answer is always contradicted.
>>
> And each correct answer is YES or NO but you do not believe that.

It is a verified fact that every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
ONLY because every answer is always contradicted. The ones that
are not contradicted are not in this set: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

Think of an infinite set of natural number subscripts for
names of Ĥ: Ĥ0.H ⟨Ĥ0⟩ ⟨Ĥ0⟩, Ĥ1.H ⟨Ĥ1⟩ ⟨Ĥ1⟩... Ĥn.H ⟨Ĥn⟩ ⟨Ĥn⟩.

--
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/21/2024 11:43 PM, immibis wrote:
> On 22/03/24 05:11, olcott wrote:
>> On 3/21/2024 10:39 PM, immibis wrote:
>>> On 22/03/24 02:49, olcott wrote:
>>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>>> On 21/03/24 19:23, olcott wrote:
>>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>>> On 21/03/24 15:21, olcott wrote:
>>>>>>>> On 3/21/2024 5:16 AM, Mikko wrote:
>>>>>>>>> On 2024-03-20 17:42:44 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/20/24 9:09 AM, olcott wrote:
>>>>>>>>>>>> On 3/20/2024 3:43 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-19 17:54:00 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>> determines that its simulated D would never stop
>>>>>>>>>>>>>>>>>>>>>>>> running unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY
>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY DETERMINES that its D will never stop
>>>>>>>>>>>>>>>>>>>>>>> running, unless THIS H aborts it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You never seemed to get the idea that X is a
>>>>>>>>>>>>>>>>>>>>>> member of set Y
>>>>>>>>>>>>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That seems to be your problem, you are listing TWO
>>>>>>>>>>>>>>>>>>>>> distinct sets, which hae two distinct set of
>>>>>>>>>>>>>>>>>>>>> Deciders and two distince to of inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You can't argue about an input built on a different
>>>>>>>>>>>>>>>>>>>>> decider tells you anything about the input built on
>>>>>>>>>>>>>>>>>>>>> THIS decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to
>>>>>>>>>>>>>>>>>>>> abort its simulation
>>>>>>>>>>>>>>>>>>>> to prevent D(D) from infinite execution that this
>>>>>>>>>>>>>>>>>>>> proves that it never
>>>>>>>>>>>>>>>>>>>> needed to abort its simulation because it can rely
>>>>>>>>>>>>>>>>>>>> on the fact that it
>>>>>>>>>>>>>>>>>>>> already aborted its simulation thus never needed to
>>>>>>>>>>>>>>>>>>>> abort it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Use of double quantifiers may be a little confusing as
>>>>>>>>>>>>>>>>> each D calls
>>>>>>>>>>>>>>>>> only one H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Counter factual*
>>>>>>>>>>>>>>>> My syntax is intended to specify the universe of H/D
>>>>>>>>>>>>>>>> pairs such that
>>>>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then you should quantify over those pairs with a simgle
>>>>>>>>>>>>>>> quantifier.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That wold not allow H and D to vary independently.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because the first thing after the quantifiers is to remove
>>>>>>>>>>>>> this
>>>>>>>>>>>>> independency there is no need to allow it.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Anyway, every pair has a different D.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *I proved otherwise below*
>>>>>>>>>>>>>> In infinite number of different H
>>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>>> all operate on the exact same D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> In infinite number of different D
>>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>>> are all input to the exact same H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That there can be multiple H for every unique D and
>>>>>>>>>>>>>>>> multiple D for
>>>>>>>>>>>>>>>> every unique H becomes more obvious when understand that
>>>>>>>>>>>>>>>> we can pad
>>>>>>>>>>>>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>>>>>>>>>>>>
>>>>>>>>>>>>> There can be multiple D for every H because D is a
>>>>>>>>>>>>> parameter to H.
>>>>>>>>>>>>> There cannot be multiple H for any D because H is not a
>>>>>>>>>>>>> parameter
>>>>>>>>>>>>> to D and only one H is included in D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because the
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> For every combination of H/D pairs such that
>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>> There can be
>>>>>>>>>>>> multiple finite strings of machine-code of D for a single H
>>>>>>>>>>>> and
>>>>>>>>>>>> multiple finite strings of machine-code of H for a single D.
>>>>>>>>>>>> The differences may simply be a different number of NOP
>>>>>>>>>>>> padding.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, a given D might "call" any of a number of different (but
>>>>>>>>>>> are EQUIVALENT) Hs. But no "H" that isn't EQUIVALENT to those
>>>>>>>>>>> (Equivalent means gives the exact same output for the exact
>>>>>>>>>>> same inputs)
>>>>>>>>>>>
>>>>>>>>>>> But your wildly different Hs that your first select over give
>>>>>>>>>>> many different equivalency classes, and a given D only is
>>>>>>>>>>> paired with one.
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> *That you already know that no D simulated by any H can possibly*
>>>>>>>>>> *reach its own line 06 in any finite number of steps of correct*
>>>>>>>>>> *simulation proves that you know that I am correct*
>>>>>>>>>>
>>>>>>>>>> That you keep trying to change the subject to a different
>>>>>>>>>> instance
>>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>>
>>>>>>>>> That you keep trying to change the subject to a different instance
>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every element of the infinite set of H/D pairs has the same
>>>>>>>> semantic
>>>>>>>> property and the differences between elements is totally irrelevant
>>>>>>>> to this shared semantic property.
>>>>>>>>
>>>>>>>> It is the case that every element of the set of H/D pairs where H
>>>>>>>> simulates its input is correct when it determines to abort this
>>>>>>>> simulation otherwise itself would never stop running.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Semantic properties are irrelevant to actual behaviour.
>>>>>>
>>>>>> The actual behavior is the behavior of N steps of D(D) correctly
>>>>>> simulated by H(D,D).
>>>>>
>>>>> Where N is the number of steps until it halts.
>>>>>
>>>>>> The actual behavior of D(D) is not the same as N steps of D(D)
>>>>>> correctly simulated by H(D,D).
>>>>>
>>>>> You literally just said it was.
>>>>>
>>>>
>>>> The actual behavior of [THE DIRECTLY EXECUTED] D(D) is not
>>>> the same as N steps of D(D) correctly simulated by H(D,D).
>>>
>>> The actual behaviour of the directly executed X(Y) is the same as the
>>> actual behaviour of X(Y) correctly simulated by any correct simulator
>>> OR ELSE IT IS NOT A CORRECT SIMULATOR.
>>
>> Every continues to say that even when the very obvious facts
>> prove them wrong. No simulated H(D,D) called from a simulated
>> D(D) can possibly return to this simulated D(D). Every directly
>> executed H(D,D) always returns to its caller.
>
> H isn't a correct simulator, so this doesn't contradict what I said.

On 22/03/24 05:29, olcott wrote:
> On 3/21/2024 11:20 PM, immibis wrote:
>> On 22/03/24 04:50, olcott wrote:
>>> On 3/21/2024 10:43 PM, immibis wrote:
>>>> On 21/03/24 19:31, olcott wrote:
>>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>>> On 21/03/24 05:34, olcott wrote:
>>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>>>>> On 20/03/24 23:52, 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 }
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Your question is meaningless.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Software engineering forums disagree.
>>>>>>>>>
>>>>>>>> Then they are stupid. Obviously this question cannot be answered
>>>>>>>> without seeing the exact code of H, and then there is also the
>>>>>>>> question about what "correctly simulated" and "terminate
>>>>>>>> normally" mean.
>>>>>>>
>>>>>>> The code is available.
>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>
>>>>>>> It Simulates according to the c source code.
>>>>>>> Few people understand x86 assembly langugae.
>>>>>>
>>>>>> You cheat the halting problem because D is not a complete program,
>>>>>> it can specify anything and everything, including making mashed
>>>>>> potatoes.
>>>>>
>>>>> D is precisely isomorphic to the Strachey P.
>>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>>
>>>> The Strachey P is a very short illustration of the problem which
>>>> does not explain the details. It gets the main point across in a
>>>> very short space, but only the main point and not the details.
>>>> Because it does not explain the details it cannot be relied on to be
>>>> correct in detail.
>>>
>>> The only relevant detail is the same as my H(D,D) != Halts(D,D)
>>> because every return value is contradicted.
>>>
>> In other words, every return value is wrong.
>
> The correct return value is contradicted making
> a correct return value a logical impossibility.

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?

>
> 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 22/03/24 05:51, olcott wrote:
> On 3/21/2024 10:35 PM, immibis wrote:
>> On 22/03/24 03:45, olcott wrote:
>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>> On 21/03/24 19:24, olcott wrote:
>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>> On 21/03/24 15:32, olcott wrote:
>>>>>>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>>>>>>
>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>> correct answer is NO.
>>>>>>>
>>>>>>>> And if H^.H (H^) (H^) says No, then the correct answer is Yes
>>>>>>>
>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>> correct answer is YES.
>>>>>>
>>>>>> In other words you believe there are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of
>>>>>> the above set which say YES or NO.
>>>>>
>>>>> Not at all. You did not read my words correctly.
>>>>>
>>>> I read them correctly.
>>>
>>> Every element in the above set says YES or NO, none of them
>>> do this correctly because their answer is always contradicted.
>>>
>> And each correct answer is YES or NO but you do not believe that.
>
> It is a verified fact that every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
> ONLY because every answer is always contradicted. The ones that
> are not contradicted are not in this set: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Think of an infinite set of natural number subscripts for
> names of Ĥ: Ĥ0.H ⟨Ĥ0⟩ ⟨Ĥ0⟩, Ĥ1.H ⟨Ĥ1⟩ ⟨Ĥ1⟩... Ĥn.H ⟨Ĥn⟩ ⟨Ĥn⟩.

Objection, irrelevant. It is a verified fact that each correct answer is
YES or NO.

On 22/03/24 05:57, olcott wrote:
> On 3/21/2024 11:43 PM, immibis wrote:
>> On 22/03/24 05:11, olcott wrote:
>>> On 3/21/2024 10:39 PM, immibis wrote:
>>>> On 22/03/24 02:49, olcott wrote:
>>>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>>>> On 21/03/24 19:23, olcott wrote:
>>>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>>>> On 21/03/24 15:21, olcott wrote:
>>>>>>>>> On 3/21/2024 5:16 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-20 17:42:44 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/20/24 9:09 AM, olcott wrote:
>>>>>>>>>>>>> On 3/20/2024 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-19 17:54:00 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>> determines that its simulated D would never
>>>>>>>>>>>>>>>>>>>>>>>>> stop running unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY
>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY DETERMINES that its D will never stop
>>>>>>>>>>>>>>>>>>>>>>>> running, unless THIS H aborts it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You never seemed to get the idea that X is a
>>>>>>>>>>>>>>>>>>>>>>> member of set Y
>>>>>>>>>>>>>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That seems to be your problem, you are listing TWO
>>>>>>>>>>>>>>>>>>>>>> distinct sets, which hae two distinct set of
>>>>>>>>>>>>>>>>>>>>>> Deciders and two distince to of inputs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You can't argue about an input built on a
>>>>>>>>>>>>>>>>>>>>>> different decider tells you anything about the
>>>>>>>>>>>>>>>>>>>>>> input built on THIS decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to
>>>>>>>>>>>>>>>>>>>>> abort its simulation
>>>>>>>>>>>>>>>>>>>>> to prevent D(D) from infinite execution that this
>>>>>>>>>>>>>>>>>>>>> proves that it never
>>>>>>>>>>>>>>>>>>>>> needed to abort its simulation because it can rely
>>>>>>>>>>>>>>>>>>>>> on the fact that it
>>>>>>>>>>>>>>>>>>>>> already aborted its simulation thus never needed to
>>>>>>>>>>>>>>>>>>>>> abort it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Use of double quantifiers may be a little confusing as
>>>>>>>>>>>>>>>>>> each D calls
>>>>>>>>>>>>>>>>>> only one H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Counter factual*
>>>>>>>>>>>>>>>>> My syntax is intended to specify the universe of H/D
>>>>>>>>>>>>>>>>> pairs such that
>>>>>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then you should quantify over those pairs with a simgle
>>>>>>>>>>>>>>>> quantifier.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That wold not allow H and D to vary independently.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because the first thing after the quantifiers is to remove
>>>>>>>>>>>>>> this
>>>>>>>>>>>>>> independency there is no need to allow it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Anyway, every pair has a different D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *I proved otherwise below*
>>>>>>>>>>>>>>> In infinite number of different H
>>>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>>>> all operate on the exact same D.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In infinite number of different D
>>>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>>>> are all input to the exact same H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That there can be multiple H for every unique D and
>>>>>>>>>>>>>>>>> multiple D for
>>>>>>>>>>>>>>>>> every unique H becomes more obvious when understand
>>>>>>>>>>>>>>>>> that we can pad
>>>>>>>>>>>>>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There can be multiple D for every H because D is a
>>>>>>>>>>>>>> parameter to H.
>>>>>>>>>>>>>> There cannot be multiple H for any D because H is not a
>>>>>>>>>>>>>> parameter
>>>>>>>>>>>>>> to D and only one H is included in D.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because the
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> For every combination of H/D pairs such that
>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>> There can be
>>>>>>>>>>>>> multiple finite strings of machine-code of D for a single H
>>>>>>>>>>>>> and
>>>>>>>>>>>>> multiple finite strings of machine-code of H for a single D.
>>>>>>>>>>>>> The differences may simply be a different number of NOP
>>>>>>>>>>>>> padding.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, a given D might "call" any of a number of different
>>>>>>>>>>>> (but are EQUIVALENT) Hs. But no "H" that isn't EQUIVALENT to
>>>>>>>>>>>> those (Equivalent means gives the exact same output for the
>>>>>>>>>>>> exact same inputs)
>>>>>>>>>>>>
>>>>>>>>>>>> But your wildly different Hs that your first select over
>>>>>>>>>>>> give many different equivalency classes, and a given D only
>>>>>>>>>>>> is paired with one.
>>>>>>>>>>>
>>>>>>>>>>> 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 }
>>>>>>>>>>>
>>>>>>>>>>> *That you already know that no D simulated by any H can
>>>>>>>>>>> possibly*
>>>>>>>>>>> *reach its own line 06 in any finite number of steps of correct*
>>>>>>>>>>> *simulation proves that you know that I am correct*
>>>>>>>>>>>
>>>>>>>>>>> That you keep trying to change the subject to a different
>>>>>>>>>>> instance
>>>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>>>
>>>>>>>>>> That you keep trying to change the subject to a different
>>>>>>>>>> instance
>>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Every element of the infinite set of H/D pairs has the same
>>>>>>>>> semantic
>>>>>>>>> property and the differences between elements is totally
>>>>>>>>> irrelevant
>>>>>>>>> to this shared semantic property.
>>>>>>>>>
>>>>>>>>> It is the case that every element of the set of H/D pairs where H
>>>>>>>>> simulates its input is correct when it determines to abort this
>>>>>>>>> simulation otherwise itself would never stop running.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Semantic properties are irrelevant to actual behaviour.
>>>>>>>
>>>>>>> The actual behavior is the behavior of N steps of D(D) correctly
>>>>>>> simulated by H(D,D).
>>>>>>
>>>>>> Where N is the number of steps until it halts.
>>>>>>
>>>>>>> The actual behavior of D(D) is not the same as N steps of D(D)
>>>>>>> correctly simulated by H(D,D).
>>>>>>
>>>>>> You literally just said it was.
>>>>>>
>>>>>
>>>>> The actual behavior of [THE DIRECTLY EXECUTED] D(D) is not
>>>>> the same as N steps of D(D) correctly simulated by H(D,D).
>>>>
>>>> The actual behaviour of the directly executed X(Y) is the same as
>>>> the actual behaviour of X(Y) correctly simulated by any correct
>>>> simulator OR ELSE IT IS NOT A CORRECT SIMULATOR.
>>>
>>> Every continues to say that even when the very obvious facts
>>> prove them wrong. No simulated H(D,D) called from a simulated
>>> D(D) can possibly return to this simulated D(D). Every directly
>>> executed H(D,D) always returns to its caller.
>>
>> H isn't a correct simulator, so this doesn't contradict what I said.
>
> It is an easily verified fact that H is a correct simulator for
> all of the steps that it simulates.

On 3/22/2024 12:04 AM, immibis wrote:
> On 22/03/24 05:57, olcott wrote:
>> On 3/21/2024 11:43 PM, immibis wrote:
>>> On 22/03/24 05:11, olcott wrote:
>>>> On 3/21/2024 10:39 PM, immibis wrote:
>>>>> On 22/03/24 02:49, olcott wrote:
>>>>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>>>>> On 21/03/24 19:23, olcott wrote:
>>>>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>>>>> On 21/03/24 15:21, olcott wrote:
>>>>>>>>>> On 3/21/2024 5:16 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-20 17:42:44 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/20/24 9:09 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/20/2024 3:43 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-19 17:54:00 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> determines that its simulated D would never
>>>>>>>>>>>>>>>>>>>>>>>>>> stop running unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY
>>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY DETERMINES that its D will never stop
>>>>>>>>>>>>>>>>>>>>>>>>> running, unless THIS H aborts it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You never seemed to get the idea that X is a
>>>>>>>>>>>>>>>>>>>>>>>> member of set Y
>>>>>>>>>>>>>>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That seems to be your problem, you are listing
>>>>>>>>>>>>>>>>>>>>>>> TWO distinct sets, which hae two distinct set of
>>>>>>>>>>>>>>>>>>>>>>> Deciders and two distince to of inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You can't argue about an input built on a
>>>>>>>>>>>>>>>>>>>>>>> different decider tells you anything about the
>>>>>>>>>>>>>>>>>>>>>>> input built on THIS decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to
>>>>>>>>>>>>>>>>>>>>>> abort its simulation
>>>>>>>>>>>>>>>>>>>>>> to prevent D(D) from infinite execution that this
>>>>>>>>>>>>>>>>>>>>>> proves that it never
>>>>>>>>>>>>>>>>>>>>>> needed to abort its simulation because it can rely
>>>>>>>>>>>>>>>>>>>>>> on the fact that it
>>>>>>>>>>>>>>>>>>>>>> already aborted its simulation thus never needed
>>>>>>>>>>>>>>>>>>>>>> to abort it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Use of double quantifiers may be a little confusing
>>>>>>>>>>>>>>>>>>> as each D calls
>>>>>>>>>>>>>>>>>>> only one H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Counter factual*
>>>>>>>>>>>>>>>>>> My syntax is intended to specify the universe of H/D
>>>>>>>>>>>>>>>>>> pairs such that
>>>>>>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then you should quantify over those pairs with a simgle
>>>>>>>>>>>>>>>>> quantifier.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That wold not allow H and D to vary independently.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because the first thing after the quantifiers is to
>>>>>>>>>>>>>>> remove this
>>>>>>>>>>>>>>> independency there is no need to allow it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Anyway, every pair has a different D.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *I proved otherwise below*
>>>>>>>>>>>>>>>> In infinite number of different H
>>>>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>>>>> all operate on the exact same D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In infinite number of different D
>>>>>>>>>>>>>>>> (all having a different number of NOP padding)
>>>>>>>>>>>>>>>> are all input to the exact same H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Above you said the opposite.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That there can be multiple H for every unique D and
>>>>>>>>>>>>>>>>>> multiple D for
>>>>>>>>>>>>>>>>>> every unique H becomes more obvious when understand
>>>>>>>>>>>>>>>>>> that we can pad
>>>>>>>>>>>>>>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There can be multiple D for every H because D is a
>>>>>>>>>>>>>>> parameter to H.
>>>>>>>>>>>>>>> There cannot be multiple H for any D because H is not a
>>>>>>>>>>>>>>> parameter
>>>>>>>>>>>>>>> to D and only one H is included in D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because the
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> For every combination of H/D pairs such that
>>>>>>>>>>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>>>>>>> There can be
>>>>>>>>>>>>>> multiple finite strings of machine-code of D for a single H
>>>>>>>>>>>>>> and
>>>>>>>>>>>>>> multiple finite strings of machine-code of H for a single D.
>>>>>>>>>>>>>> The differences may simply be a different number of NOP
>>>>>>>>>>>>>> padding.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, a given D might "call" any of a number of different
>>>>>>>>>>>>> (but are EQUIVALENT) Hs. But no "H" that isn't EQUIVALENT
>>>>>>>>>>>>> to those (Equivalent means gives the exact same output for
>>>>>>>>>>>>> the exact same inputs)
>>>>>>>>>>>>>
>>>>>>>>>>>>> But your wildly different Hs that your first select over
>>>>>>>>>>>>> give many different equivalency classes, and a given D only
>>>>>>>>>>>>> is paired with one.
>>>>>>>>>>>>
>>>>>>>>>>>> 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 }
>>>>>>>>>>>>
>>>>>>>>>>>> *That you already know that no D simulated by any H can
>>>>>>>>>>>> possibly*
>>>>>>>>>>>> *reach its own line 06 in any finite number of steps of
>>>>>>>>>>>> correct*
>>>>>>>>>>>> *simulation proves that you know that I am correct*
>>>>>>>>>>>>
>>>>>>>>>>>> That you keep trying to change the subject to a different
>>>>>>>>>>>> instance
>>>>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>>>>
>>>>>>>>>>> That you keep trying to change the subject to a different
>>>>>>>>>>> instance
>>>>>>>>>>> of D is ALWAYS an instance of the strawman deception.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every element of the infinite set of H/D pairs has the same
>>>>>>>>>> semantic
>>>>>>>>>> property and the differences between elements is totally
>>>>>>>>>> irrelevant
>>>>>>>>>> to this shared semantic property.
>>>>>>>>>>
>>>>>>>>>> It is the case that every element of the set of H/D pairs where H
>>>>>>>>>> simulates its input is correct when it determines to abort this
>>>>>>>>>> simulation otherwise itself would never stop running.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Semantic properties are irrelevant to actual behaviour.
>>>>>>>>
>>>>>>>> The actual behavior is the behavior of N steps of D(D) correctly
>>>>>>>> simulated by H(D,D).
>>>>>>>
>>>>>>> Where N is the number of steps until it halts.
>>>>>>>
>>>>>>>> The actual behavior of D(D) is not the same as N steps of D(D)
>>>>>>>> correctly simulated by H(D,D).
>>>>>>>
>>>>>>> You literally just said it was.
>>>>>>>
>>>>>>
>>>>>> The actual behavior of [THE DIRECTLY EXECUTED] D(D) is not
>>>>>> the same as N steps of D(D) correctly simulated by H(D,D).
>>>>>
>>>>> The actual behaviour of the directly executed X(Y) is the same as
>>>>> the actual behaviour of X(Y) correctly simulated by any correct
>>>>> simulator OR ELSE IT IS NOT A CORRECT SIMULATOR.
>>>>
>>>> Every continues to say that even when the very obvious facts
>>>> prove them wrong. No simulated H(D,D) called from a simulated
>>>> D(D) can possibly return to this simulated D(D). Every directly
>>>> executed H(D,D) always returns to its caller.
>>>
>>> H isn't a correct simulator, so this doesn't contradict what I said.
>>
>> It is an easily verified fact that H is a correct simulator for
>> all of the steps that it simulates.
>
> Is it a correct simulator, or is it only a correct simulator for the
> steps that it simulates?

On 3/22/2024 12:04 AM, immibis wrote:
> On 22/03/24 05:51, olcott wrote:
>> On 3/21/2024 10:35 PM, immibis wrote:
>>> On 22/03/24 03:45, olcott wrote:
>>>> On 3/21/2024 8:27 PM, immibis wrote:
>>>>> On 21/03/24 19:24, olcott wrote:
>>>>>> On 3/21/2024 1:04 PM, immibis wrote:
>>>>>>> On 21/03/24 15:32, olcott wrote:
>>>>>>>>> And if H^,H (H^) (H^) says Yes, then the correct answer is No
>>>>>>>>
>>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>>> correct answer is NO.
>>>>>>>>
>>>>>>>>> And if H^.H (H^) (H^) says No, then the correct answer is Yes
>>>>>>>>
>>>>>>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of the above set where the
>>>>>>>> correct answer is YES.
>>>>>>>
>>>>>>> In other words you believe there are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ elements of
>>>>>>> the above set which say YES or NO.
>>>>>>
>>>>>> Not at all. You did not read my words correctly.
>>>>>>
>>>>> I read them correctly.
>>>>
>>>> Every element in the above set says YES or NO, none of them
>>>> do this correctly because their answer is always contradicted.
>>>>
>>> And each correct answer is YES or NO but you do not believe that.
>>
>> It is a verified fact that every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>> ONLY because every answer is always contradicted. The ones that
>> are not contradicted are not in this set: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Think of an infinite set of natural number subscripts for
>> names of Ĥ: Ĥ0.H ⟨Ĥ0⟩ ⟨Ĥ0⟩, Ĥ1.H ⟨Ĥ1⟩ ⟨Ĥ1⟩... Ĥn.H ⟨Ĥn⟩ ⟨Ĥn⟩.
>
> Objection, irrelevant. It is a verified fact that each correct answer is
> YES or NO.
>

The ones that are correct are not in the set: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is contradicted forcing it to be incorrect.

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