On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
> Op 20.mrt.2024 om 20:07 schreef olcott:
>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>
>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort
>>>>>>>>>>>>>>>>>>>> or fail to abort?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells
>>>>>>>>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>>>>>>> decider then
>>>>>>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>>>>>>> prerequisite
>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the
>>>>>>>>>>>>>>> Olcott abort problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You can learn calculus without the basis of algebra. You
>>>>>>>>>>>>>> can't learn
>>>>>>>>>>>>>> simulating halt deciders without the basis of simulating
>>>>>>>>>>>>>> abort deciders.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When are you going to extend this theory of simulating
>>>>>>>>>>>>> abort deciders so that it solves the halting problem
>>>>>>>>>>>>> instead of merely solving the Olcott abort problem?
>>>>>>>>>>>>
>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>>>>>>> incorrect question thus must be redefined.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>
>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>
>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct
>>>>>>>>> answer to all entities.
>>>>>>>>
>>>>>>>> *counter factual*
>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>
>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>
>>>>>>
>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>> correctly reporting on what they actually see.
>>>>>
>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>
>>>>
>>>> *That would cause D(D) to loop, thus wrong answer*
>>> No. The H that answers 'yes' is a different H.
>>
>> Can D correctly simulated by H terminate normally?
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> Every H(D,D) that does not abort its simulation input never
>> stops running.
>>
>>> It would be correct for this D. We can build another D, based on the
>>> new H, but then the question changes, because the input changes. The
>>> new H does not give the correct answer for the new D.
>>>> *That would cause D(D) to loop, thus wrong answer*
>>> No. The H that answers 'yes' is a different H. It would be correct
>>> for this D. We can build another D, based on the new H, but then the
>>> question changes, because the input changes. The new H does not give
>>> the correct answer for the new D.
>>>> *That would cause D(D) to loop, thus wrong answer*
>>> No. The H that answers 'yes' is a different H. It would be correct
>>> for this D. We can build another D, based on the new H, but then the
>>> question changes, because the input changes. The new H does not give
>>> the correct answer for the new D.
>>>
>>> Both questions have a correct answer, but the corresponding H failed
>>> to give it. It seems Olcott is again confused, because he uses the
>>> same names for different things.
>>>
>>
>> Every H(D,D) that does not abort its simulation input never
>> stops running.
>>
>> Trying to refer to a different H than every H is a very lame
>> attempt to get away with the strawman deception.
>
> Very weak response. I did not say different from every H.
> It seems Olcott does not understand that if he speaks about 'every H'
> then not all these H are equal, but they are different. So two examples

Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.

> of such H can be different very easily. One H may answer 'no', another H
> may answer 'yes'. That is a difference that he does not understand.
> Again, he seems to be confused because he uses the same name for many
> different things.
>

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

On 20/03/24 20:30, olcott wrote:
> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>
>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells
>>>>>>>>>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>>>>>>>> decider then
>>>>>>>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>>>>>>>> prerequisite
>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the
>>>>>>>>>>>>>>>> Olcott abort problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You can learn calculus without the basis of algebra. You
>>>>>>>>>>>>>>> can't learn
>>>>>>>>>>>>>>> simulating halt deciders without the basis of simulating
>>>>>>>>>>>>>>> abort deciders.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When are you going to extend this theory of simulating
>>>>>>>>>>>>>> abort deciders so that it solves the halting problem
>>>>>>>>>>>>>> instead of merely solving the Olcott abort problem?
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>>>>>>>> incorrect question thus must be redefined.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>
>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>>
>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct
>>>>>>>>>> answer to all entities.
>>>>>>>>>
>>>>>>>>> *counter factual*
>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>
>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>
>>>>>>>
>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>> correctly reporting on what they actually see.
>>>>>>
>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>
>>>>>
>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>> No. The H that answers 'yes' is a different H.
>>>
>>> Can D correctly simulated by H terminate normally?
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> Every H(D,D) that does not abort its simulation input never
>>> stops running.
>>>
>>>> It would be correct for this D. We can build another D, based on the
>>>> new H, but then the question changes, because the input changes. The
>>>> new H does not give the correct answer for the new D.
>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>> No. The H that answers 'yes' is a different H. It would be correct
>>>> for this D. We can build another D, based on the new H, but then the
>>>> question changes, because the input changes. The new H does not give
>>>> the correct answer for the new D.
>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>> No. The H that answers 'yes' is a different H. It would be correct
>>>> for this D. We can build another D, based on the new H, but then the
>>>> question changes, because the input changes. The new H does not give
>>>> the correct answer for the new D.
>>>>
>>>> Both questions have a correct answer, but the corresponding H failed
>>>> to give it. It seems Olcott is again confused, because he uses the
>>>> same names for different things.
>>>>
>>>
>>> Every H(D,D) that does not abort its simulation input never
>>> stops running.
>>>
>>> Trying to refer to a different H than every H is a very lame
>>> attempt to get away with the strawman deception.
>>
>> Very weak response. I did not say different from every H.
>> It seems Olcott does not understand that if he speaks about 'every H'
>> then not all these H are equal, but they are different. So two examples
>
> Every H(D,D) that does not abort its simulation is exactly equal in
> that none of them ever stop running.

On 20/03/24 20:18, olcott wrote:
> On 3/20/2024 2:11 PM, Fred. Zwarts wrote:
>> Op 20.mrt.2024 om 19:35 schreef olcott:
>>> On 3/20/2024 1:13 PM, Richard Damon wrote:
>>>> On 3/20/24 12:29 PM, olcott wrote:
>>>>> On 3/20/2024 11:12 AM, Richard Damon wrote:
>>>>>> On 3/19/24 2:14 PM, olcott wrote:
>>>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>>>> You are just getting nutty now. You are tossing out the
>>>>>>>>> sequence, selection, iteration model of computation.
>>>>>>>>
>>>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>>>
>>>>>>>
>>>>>>> I am only tossing out the halting problem specification.
>>>>>>> I am not saying (like Richard is saying) that sequential
>>>>>>> code can be executed out-of-sequence.
>>>>>>>
>>>>>>
>>>>>> Just more of your lies.
>>>>>>
>>>>>> Where did I say "Sequential Code" can run out-of-sequence.
>>>>>>
>>>>>>
>>>>>> THe codes that I talk about not being in the sequence you think
>>>>>> are two INDEPENDENT copies of the machines.
>>>>>>
>>>>>
>>>>> The one that is called first is executed first.
>>>>
>>>> And I never denied that.
>>>>
>>>> But H(D,D) doesn't "Call" D(D), it simulates it.
>>>>
>>>
>>> Thus the steps of D(D) simulated by H come after H(D,D)
>>> is executed, they do not occur in parallel at the same time.
>>>
>>>> The D(D) that it simulates is a machine that has already been "run",
>>>> since Turing Machines are FULL computation devices that run their
>>>> procesisng as soon as they are created.
>>>>
>>>
>>> In some strawman deception argument the steps of D(D) come
>>> before H(D,D) is executed.
>>>
>>>> This seems something you don't understand, because you seem to think
>>>> that D(D) doesn't actually "run" until it is simulated.
>>>>
>>>
>>> The steps of the simulated D(D) are never run, they are only simulated.
>>> In a strawman deception argument the steps of D(D) are executed before
>>> the steps of H(D,D).
>>>
>>>>>
>>>>>> The H that is deciding the D(D) does not enforce that the ACTUAL
>>>>>> D(D) it is simulating has not been run yet, and in fact, since we
>>>>>> can consider Turing Machines to "auto-start" once created, it is
>>>>>> IMPOSSIBLE to give to H a description of a D(D) that has not
>>>>>> already run itself.
>>>>>>
>>>>> The one that is called first is executed first.
>>>>
>>>> So?
>>>>
>>>
>>> You tried to get away with saying otherwise.
>>>
>>>> Where does H call D(D)? It SIMULATES it.
>>>>
>>>> You seem to think that simulation is the exact same thing as EXECUTION.
>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Ĥ ⟨Ĥ⟩ is executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ thus the executed Ĥ ⟨Ĥ⟩ is
>>>>> run before the simulated one. When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ simulates its input
>>>>> it can see that it must abort this simulation.
>>>>
>>>> Yes H^ (H^) is executed before H^.H (H^) (H^) but the instance of
>>>> the machine represented by that input was executed when it was
>>>> created, so has already run.
>>>>
>>> Unless you are trying to get away with rejecting the sequence of
>>> sequence, selection, iteration you already know that Ĥ ⟨Ĥ⟩ is always
>>> executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>>> Again, you are confusing the simulation that H, or H^.H does, with
>>>> the axtual execution of them.
>>>>
>>>> You could even look at the simulation of H^.H as telling H part of
>>>> what this H^ (H^) has alteady done.
>>>>
>>>>
>>>>>
>>>>>> We, as finite humans may not know what it did, but the
>>>>>> mathematical world of truth does.
>>>>>>
>>>>>
>>>>> Mathematical induction proves that after N steps of correct simulation
>>>>> H correctly determines that ∞ steps of correct simulation would never
>>>>> halt. *These are verified facts that you perpetually deny*
>>>>
>>>> NOPE.
>>>>
>>>> STATE YOUR INDUCTION CRITERIA and their proof
>>>>
>>>
>>> As soon as H(D,D) sees that D calls itself with its same inputs
>>> and there are no conditional branch instructions from the
>>> beginning of D to its call to H(D,D) then H knows that its
>>> simulated D(D) cannot possibly reach its own final instruction
>>> (at line 06) in any finite number of steps of correct simulation.
>>
>> An infinite recursion could be detected if a program comes back at the
>> same place in the same state. In this case the beginning of D and the
>> call to H are not the same place within the program. What Olcott
>> means, but does not say, is that the call from D to H causes the
>> program to arrive at a similar place in a similar state as when H (not
>> D) started. But now we see that there are conditional branch
>> instructions between these two places, namely within H, which may
>> cause an end of the recursion. In fact, it is known that the recursion
>> is not infinite, but does end, because H aborts and returns.
>
> There are no conditional branch instructions that allow
> the simulated D(D) to reach its own final state and halt.

There is a conditional branch instruction which causes the simulated
H(D,D) to reach its final state and return 0. However, the simulation of
H(D,D) is aborted before the simulated H(D,D) reaches this instruction.

>
> In fact neither the simulated D(D) nor the executed H(D,D) can
> possibly stop running unless the executed H(D,D) aborts its
> simulation without waiting for any simulated H(D,D) to do this.
>

On 3/20/2024 2:32 PM, immibis wrote:
> On 20/03/24 20:30, olcott wrote:
>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells
>>>>>>>>>>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>>>>>>>>> decider then
>>>>>>>>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>>>>>>>>> prerequisite
>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the
>>>>>>>>>>>>>>>>> Olcott abort problem.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You can learn calculus without the basis of algebra. You
>>>>>>>>>>>>>>>> can't learn
>>>>>>>>>>>>>>>> simulating halt deciders without the basis of simulating
>>>>>>>>>>>>>>>> abort deciders.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When are you going to extend this theory of simulating
>>>>>>>>>>>>>>> abort deciders so that it solves the halting problem
>>>>>>>>>>>>>>> instead of merely solving the Olcott abort problem?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>>>>>>>>> incorrect question thus must be redefined.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>>>
>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct
>>>>>>>>>>> answer to all entities.
>>>>>>>>>>
>>>>>>>>>> *counter factual*
>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>
>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>
>>>>>>>>
>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>> correctly reporting on what they actually see.
>>>>>>>
>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>
>>>>>>
>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>> No. The H that answers 'yes' is a different H.
>>>>
>>>> Can D correctly simulated by H terminate normally?
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> Every H(D,D) that does not abort its simulation input never
>>>> stops running.
>>>>
>>>>> It would be correct for this D. We can build another D, based on
>>>>> the new H, but then the question changes, because the input
>>>>> changes. The new H does not give the correct answer for the new D.
>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>> No. The H that answers 'yes' is a different H. It would be correct
>>>>> for this D. We can build another D, based on the new H, but then
>>>>> the question changes, because the input changes. The new H does not
>>>>> give the correct answer for the new D.
>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>> No. The H that answers 'yes' is a different H. It would be correct
>>>>> for this D. We can build another D, based on the new H, but then
>>>>> the question changes, because the input changes. The new H does not
>>>>> give the correct answer for the new D.
>>>>>
>>>>> Both questions have a correct answer, but the corresponding H
>>>>> failed to give it. It seems Olcott is again confused, because he
>>>>> uses the same names for different things.
>>>>>
>>>>
>>>> Every H(D,D) that does not abort its simulation input never
>>>> stops running.
>>>>
>>>> Trying to refer to a different H than every H is a very lame
>>>> attempt to get away with the strawman deception.
>>>
>>> Very weak response. I did not say different from every H.
>>> It seems Olcott does not understand that if he speaks about 'every H'
>>> then not all these H are equal, but they are different. So two examples
>>
>> Every H(D,D) that does not abort its simulation is exactly equal in
>> that none of them ever stop running.
>
> That's not actually true. If we call
> H_exact_simulation_that_does_not_abort(D,D) (such as qemu) we see that
> it correctly returns 'yes', because D(D) calls H(D,D), which returns 0,
> and then D(D) returns, and then
> H_exact_simulation_that_does_not_abort(D,D) returns 1.
>

On 3/20/2024 2:33 PM, immibis wrote:
> On 20/03/24 20:18, olcott wrote:
>> On 3/20/2024 2:11 PM, Fred. Zwarts wrote:
>>> Op 20.mrt.2024 om 19:35 schreef olcott:
>>>> On 3/20/2024 1:13 PM, Richard Damon wrote:
>>>>> On 3/20/24 12:29 PM, olcott wrote:
>>>>>> On 3/20/2024 11:12 AM, Richard Damon wrote:
>>>>>>> On 3/19/24 2:14 PM, olcott wrote:
>>>>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>>>>> You are just getting nutty now. You are tossing out the
>>>>>>>>>> sequence, selection, iteration model of computation.
>>>>>>>>>
>>>>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am only tossing out the halting problem specification.
>>>>>>>> I am not saying (like Richard is saying) that sequential
>>>>>>>> code can be executed out-of-sequence.
>>>>>>>>
>>>>>>>
>>>>>>> Just more of your lies.
>>>>>>>
>>>>>>> Where did I say "Sequential Code" can run out-of-sequence.
>>>>>>>
>>>>>>>
>>>>>>> THe codes that I talk about not being in the sequence you think
>>>>>>> are two INDEPENDENT copies of the machines.
>>>>>>>
>>>>>>
>>>>>> The one that is called first is executed first.
>>>>>
>>>>> And I never denied that.
>>>>>
>>>>> But H(D,D) doesn't "Call" D(D), it simulates it.
>>>>>
>>>>
>>>> Thus the steps of D(D) simulated by H come after H(D,D)
>>>> is executed, they do not occur in parallel at the same time.
>>>>
>>>>> The D(D) that it simulates is a machine that has already been
>>>>> "run", since Turing Machines are FULL computation devices that run
>>>>> their procesisng as soon as they are created.
>>>>>
>>>>
>>>> In some strawman deception argument the steps of D(D) come
>>>> before H(D,D) is executed.
>>>>
>>>>> This seems something you don't understand, because you seem to
>>>>> think that D(D) doesn't actually "run" until it is simulated.
>>>>>
>>>>
>>>> The steps of the simulated D(D) are never run, they are only simulated.
>>>> In a strawman deception argument the steps of D(D) are executed before
>>>> the steps of H(D,D).
>>>>
>>>>>>
>>>>>>> The H that is deciding the D(D) does not enforce that the ACTUAL
>>>>>>> D(D) it is simulating has not been run yet, and in fact, since we
>>>>>>> can consider Turing Machines to "auto-start" once created, it is
>>>>>>> IMPOSSIBLE to give to H a description of a D(D) that has not
>>>>>>> already run itself.
>>>>>>>
>>>>>> The one that is called first is executed first.
>>>>>
>>>>> So?
>>>>>
>>>>
>>>> You tried to get away with saying otherwise.
>>>>
>>>>> Where does H call D(D)? It SIMULATES it.
>>>>>
>>>>> You seem to think that simulation is the exact same thing as
>>>>> EXECUTION.
>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Ĥ ⟨Ĥ⟩ is executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ thus the executed Ĥ ⟨Ĥ⟩ is
>>>>>> run before the simulated one. When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ simulates its input
>>>>>> it can see that it must abort this simulation.
>>>>>
>>>>> Yes H^ (H^) is executed before H^.H (H^) (H^) but the instance of
>>>>> the machine represented by that input was executed when it was
>>>>> created, so has already run.
>>>>>
>>>> Unless you are trying to get away with rejecting the sequence of
>>>> sequence, selection, iteration you already know that Ĥ ⟨Ĥ⟩ is always
>>>> executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>>> Again, you are confusing the simulation that H, or H^.H does, with
>>>>> the axtual execution of them.
>>>>>
>>>>> You could even look at the simulation of H^.H as telling H part of
>>>>> what this H^ (H^) has alteady done.
>>>>>
>>>>>
>>>>>>
>>>>>>> We, as finite humans may not know what it did, but the
>>>>>>> mathematical world of truth does.
>>>>>>>
>>>>>>
>>>>>> Mathematical induction proves that after N steps of correct
>>>>>> simulation
>>>>>> H correctly determines that ∞ steps of correct simulation would never
>>>>>> halt. *These are verified facts that you perpetually deny*
>>>>>
>>>>> NOPE.
>>>>>
>>>>> STATE YOUR INDUCTION CRITERIA and their proof
>>>>>
>>>>
>>>> As soon as H(D,D) sees that D calls itself with its same inputs
>>>> and there are no conditional branch instructions from the
>>>> beginning of D to its call to H(D,D) then H knows that its
>>>> simulated D(D) cannot possibly reach its own final instruction
>>>> (at line 06) in any finite number of steps of correct simulation.
>>>
>>> An infinite recursion could be detected if a program comes back at
>>> the same place in the same state. In this case the beginning of D and
>>> the call to H are not the same place within the program. What Olcott
>>> means, but does not say, is that the call from D to H causes the
>>> program to arrive at a similar place in a similar state as when H
>>> (not D) started. But now we see that there are conditional branch
>>> instructions between these two places, namely within H, which may
>>> cause an end of the recursion. In fact, it is known that the
>>> recursion is not infinite, but does end, because H aborts and returns.
>>
>> There are no conditional branch instructions that allow
>> the simulated D(D) to reach its own final state and halt.
>
> There is a conditional branch instruction which causes the simulated
> H(D,D) to reach its final state and return 0. However,

> the simulation of
> H(D,D) is aborted before the simulated H(D,D) reaches this instruction.
>

That proves a lack of sufficient software engineering skills.
What are your programming skills?

I have been a professional developer since 1984 and a professional
C++ software engineer since 2000.

>>
>> In fact neither the simulated D(D) nor the executed H(D,D) can
>> possibly stop running unless the executed H(D,D) aborts its
>> simulation without waiting for any simulated H(D,D) to do this.
>>
>

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

On 20/03/24 19:17, olcott wrote:
> On 3/20/2024 1:00 PM, Richard Damon wrote:
>> On 3/19/24 2:53 PM, olcott wrote:
>>> On 3/19/2024 1:31 PM, immibis wrote:
>>>> On 19/03/24 19:14, olcott wrote:
>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>>>> selection, iteration model of computation.
>>>>>>
>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>
>>>>>
>>>>> I am only tossing out the halting problem specification.
>>>>> I am not saying (like Richard is saying) that sequential
>>>>> code can be executed out-of-sequence.
>>>>>
>>>>
>>>> in other words you accept the halting problem is unsolvable and want
>>>> to work on a different problem instead.
>>>
>>> Incorrect questions are questions defined to have no correct
>>> answer. Is this sentence true or false: "This sentence is not true."
>>> Is a concrete example of an incorrect question. A less subtle example
>>> is this question: Is this sentence true or false: "What time is it?"
>>
>> Right, but "Does the machine described by your input Halt?"
>>
>> DOES have a correct answer (just not the one that this H gives) so it
>> is a CORRECT question.
>>
>>>
>>> Incorrect question instances are questions defined to have no correct
>>> answer when posed to a specific entity.  They may have correct answers
>>> when posed to a different entity.
>>
>> And the fact that the entity DOESN'T give the correct answer doesn't
>> make the question incorrect.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> When neither YES no NO is a correct answer when posed to
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ of the above template then this is an incorrect
> question instance.

One of them is the correct answer. In your x86utm example, YES is the
correct answer.

>
>>> Can Carol correctly answer “no” to this [yes/no] question?
>>>
>>> In the case of Hehner's "twisted self-reference" incorrect question
>>>   instances can be understood to be incorrect questions when the
>>>   full context of who is asked is included in the meaning of the
>>> question.
>>
>> Which, since you admit he CHANGES the question, his arguement fails to
>> be valid based on using the STRAWMAN fallacy.
>>
> It does not change the question. We are simply examining the subset
> cases when the question is applied to specific decider/input pairs.
>
> When posed to every entity named "Carol"
> the question is an {incorrect question instance}.
>

Not if the question is about a different entity named Carol.

On 3/20/2024 2:44 PM, immibis wrote:
> On 20/03/24 19:17, olcott wrote:
>> On 3/20/2024 1:00 PM, Richard Damon wrote:
>>> On 3/19/24 2:53 PM, olcott wrote:
>>>> On 3/19/2024 1:31 PM, immibis wrote:
>>>>> On 19/03/24 19:14, olcott wrote:
>>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>>> You are just getting nutty now. You are tossing out the
>>>>>>>> sequence, selection, iteration model of computation.
>>>>>>>
>>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>>
>>>>>>
>>>>>> I am only tossing out the halting problem specification.
>>>>>> I am not saying (like Richard is saying) that sequential
>>>>>> code can be executed out-of-sequence.
>>>>>>
>>>>>
>>>>> in other words you accept the halting problem is unsolvable and
>>>>> want to work on a different problem instead.
>>>>
>>>> Incorrect questions are questions defined to have no correct
>>>> answer. Is this sentence true or false: "This sentence is not true."
>>>> Is a concrete example of an incorrect question. A less subtle example
>>>> is this question: Is this sentence true or false: "What time is it?"
>>>
>>> Right, but "Does the machine described by your input Halt?"
>>>
>>> DOES have a correct answer (just not the one that this H gives) so it
>>> is a CORRECT question.
>>>
>>>>
>>>> Incorrect question instances are questions defined to have no correct
>>>> answer when posed to a specific entity.  They may have correct answers
>>>> when posed to a different entity.
>>>
>>> And the fact that the entity DOESN'T give the correct answer doesn't
>>> make the question incorrect.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> When neither YES no NO is a correct answer when posed to
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ of the above template then this is an incorrect
>> question instance.
>
> One of them is the correct answer. In your x86utm example, YES is the
> correct answer.
>

Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn says Ĥ ⟨Ĥ⟩ does not halt and then halts.

Therefore:
Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question instance when posed to Ĥ.H.

>>
>>>> Can Carol correctly answer “no” to this [yes/no] question?
>>>>
>>>> In the case of Hehner's "twisted self-reference" incorrect question
>>>>   instances can be understood to be incorrect questions when the
>>>>   full context of who is asked is included in the meaning of the
>>>> question.
>>>
>>> Which, since you admit he CHANGES the question, his arguement fails
>>> to be valid based on using the STRAWMAN fallacy.
>>>
>> It does not change the question. We are simply examining the subset
>> cases when the question is applied to specific decider/input pairs.
>>
>> When posed to every entity named "Carol"
>> the question is an {incorrect question instance}.
>>
>
> Not if the question is about a different entity named Carol.
>

Even if the question is posed to a Turing machine named Carol.

--
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/20/24 2:07 PM, olcott wrote:
> On 3/20/2024 12:10 PM, Richard Damon wrote:
>> On 3/20/24 12:08 PM, olcott wrote:
>>> On 3/20/2024 11:03 AM, Richard Damon wrote:
>>>> On 3/20/24 8:54 AM, olcott wrote:
>>>>> On 3/20/2024 3:56 AM, Mikko wrote:
>>>>>> On 2024-03-19 14:37:13 +0000, olcott said:
>>>>>>
>>>>>>> On 3/19/2024 4:24 AM, Mikko wrote:
>>>>>>>> On 2024-03-19 04:37:02 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>>>>>>>>> On 3/18/24 8:53 PM, olcott wrote:
>>>>>>>>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer the question
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have no concept of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on behavior that it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyant is an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its simulated D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ridiculously disingenuous
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can be encoded and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stupid to not see this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, the we get a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> needs to abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving the input to a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, that simulator will not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need abort its simulation and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort decision is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoded and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so no D that was built with an H that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation has had its actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting status tested.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same truism*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only two sets*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in set (2), since nothing showed them not to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>> running, and thus the top level H didn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>> need to abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you
>>>>>>>>>>>>>>>>>>>>>>>>> don't understand
>>>>>>>>>>>>>>>>>>>>>>>>> the difference between X being a member of a
>>>>>>>>>>>>>>>>>>>>>>>>> set and X not being
>>>>>>>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget
>>>>>>>>>>>>>>>>>>>>>>>> that each D that you talk about is DIFFERENT,
>>>>>>>>>>>>>>>>>>>>>>>> base on the H that it was designed to confound.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2)
>>>>>>>>>>>>>>>>>>>>>>> then H(D,D) is correct*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is
>>>>>>>>>>>>>>>>>>>> considered, or Dss? Dss must be aborted, because is
>>>>>>>>>>>>>>>>>>>> does not halt, but Dan does halt and does not need
>>>>>>>>>>>>>>>>>>>> to be aborted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (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...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>>>>>>>> *Every element of (1) is incorrect and every element
>>>>>>>>>>>>>>>>>>> of (2) is correct*
>>>>>>>>>>>>>>>>>>> *Pathological thinking to make them both seem
>>>>>>>>>>>>>>>>>>> incorrect is incorrect*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort
>>>>>>>>>>>>>>>>>>>> and the Han that does not meet its abort criteria
>>>>>>>>>>>>>>>>>>>> does abort. So, both are wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be
>>>>>>>>>>>>>>>>>> aborted, because is does not halt, but Dan does halt
>>>>>>>>>>>>>>>>>> and does not need to be aborted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *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.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are almost there. If you stop naming all different H
>>>>>>>>>>>>>>>> which the same name and all different D with the same
>>>>>>>>>>>>>>>> name, your confusion may disappear.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>>>> the Han
>>>>>>>>>>>>>>>> that does not meet its abort criteria does abort. So,
>>>>>>>>>>>>>>>> both are wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Olcott does not understand that if the H in the simulated
>>>>>>>>>>>>>> D aborts, then the simulating H should not abort
>>>>>>>>>>>>>
>>>>>>>>>>>>> *You are confused*
>>>>>>>>>>>>> If the H in the simulated D aborts then the directly
>>>>>>>>>>>>> executed H did
>>>>>>>>>>>>> not abort. Since the directly executed H sees one more
>>>>>>>>>>>>> execution
>>>>>>>>>>>>> trace then the simulated H then the H in the simulated D
>>>>>>>>>>>>> never aborts.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>>>>>>>>
>>>>>>>>>>> Then a dozen square circles are on sale at Walmart right now
>>>>>>>>>>> for $10.99
>>>>>>>>>>
>>>>>>>>>> Interesting, that you retort was to just blantently lie?
>>>>>>>>>>
>>>>>>>>>> When presented with FACTS, you respond with LIES.
>>>>>>>>>>
>>>>>>>>>> That just shows who you are.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> then the directly executed D MUST abort, or you are agreeing
>>>>>>>>>>>> that H's simulation is not correct.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> In other words after we have been over this hundreds and
>>>>>>>>>>> hundreds of times it is still waaaayyy over your head that
>>>>>>>>>>> the executed H always
>>>>>>>>>>> sees exactly one more execution trace than the executed H?
>>>>>>>>>>
>>>>>>>>>> Do you really read your nonsense?
>>>>>>>>>>
>>>>>>>>>> How does x, "the executed H" see one more execution trace than x?
>>>>>>>>>>
>>>>>>>>>> That means you think that 1 + 1 = 1
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> And no, the directed executed vesion of D see no more
>>>>>>>>>>>> information then the machine the simulated D represents,
>>>>>>>>>>>
>>>>>>>>>>> The simulated H can not see its own behavior where as its
>>>>>>>>>>> simulator
>>>>>>>>>>> can thus proving the simulator sees one more execution trace
>>>>>>>>>>> that its simulation.
>>>>>>>>>>
>>>>>>>>>> Nope, it may see one more then at the point the simulation
>>>>>>>>>> reaches,
>>>>>>>>>
>>>>>>>>> Yes, finally. Thus the executed H(D,D) sees its abort criteria
>>>>>>>>> before
>>>>>>>>> any of the simulated ones ever would.
>>>>>>>>>
>>>>>>>>>> but the actual machine that is now being simulated did
>>>>>>>>>> EVERYTHING that it will do as soon as it was created,
>>>>>>>>>>
>>>>>>>>> No it is not true that x86 machines are oracle machines.
>>>>>>>>> https://en.wikipedia.org/wiki/Oracle_machine
>>>>>>>>>
>>>>>>>>>> You keep on makeing that mistake, confusing the simulation
>>>>>>>>>> with what actually happens.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> if H aborts the simulation before then, then H just doesn't
>>>>>>>>>>>> get to know what happens after that.
>>>>>>>>>>>>
>>>>>>>>>>>> I will point out, you almost NEVER actually look at the
>>>>>>>>>>>> direct execution of D(D), because it just proves that H
>>>>>>>>>>>> isn't a correct Halt Decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H(D,D) cannot rely on the behavior of D(D) after it has
>>>>>>>>>>> already aborted
>>>>>>>>>>> its simulation or it would never abort its simulation and
>>>>>>>>>>> D(D) would
>>>>>>>>>>> never stop running. This means that the executed H(D,D) see
>>>>>>>>>>> non halting
>>>>>>>>>>> behavior.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, H is in a no-win pickle. (or its programmer is).
>>>>>>>>>
>>>>>>>>> Not at all. The requirement for clairvoyance is an incorrect
>>>>>>>>> requirement. H(D,D) cannot be correctly required to report on
>>>>>>>>> what it cannot see.
>>>>>>>>>
>>>>>>>>>> If we wait, we run into the issue that we may never answer. If
>>>>>>>>>> we abort, we don't know what answer to give.
>>>>>>>>>
>>>>>>>>> An abort decider would report on whether it aborted or not.
>>>>>>>>>
>>>>>>>>>> That is why the Halting Mapping turns out to be uncomputable.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *H(D,D) cannot be correctly required to report on what it
>>>>>>>>> cannot see*
>>>>>>>>
>>>>>>>> A requirement is correct if it is possible to determine
>>>>>>>> whether the requirement is satisfied in a particular case.
>>>>>>>>
>>>>>>>
>>>>>>> Any requirement that ever requires the logically impossible is
>>>>>>> never correct in these cases where it requires the logically
>>>>>>> impossible.
>>>>>>
>>>>>> That is not what the word "correct" means.
>>>>>>
>>>>>
>>>>> Logical impossibilities never place any actual limit on anyone
>>>>> or anything.
>>>>>
>>>>>
>>>>
>>>> But knowledge of what is logically impossible helps us to KNOW what
>>>> are the actual limits.
>>>
>>> We cannot expect anyone to correctly answer this question:
>>> What time is it (yes or no) ?
>>
>> Right, because that is an INVALID question, as its answer is NOT yes
>> or no
>>
>>>
>>> Likewise every decision problem with undecidable instances is
>>> merely an incorrect question instance in these undecidable instances.
>>>
>>
>> Nope.
>>
>> Just shows you are continuing to LIE about what the definition of
>> those terms are.
>>
>> And, that you are totally ignorant of those meanings.
>
> Since I defined the term "incorrect question" and I defined the
> term "incorrect question instance" I cannot possibly have defined
> them incorrectly. These are stipulative definitions.
> https://en.wikipedia.org/wiki/Stipulative_definition

On 20/03/24 20:50, olcott wrote:
> On 3/20/2024 2:44 PM, immibis wrote:
>> On 20/03/24 19:17, olcott wrote:
>>> On 3/20/2024 1:00 PM, Richard Damon wrote:
>>>> On 3/19/24 2:53 PM, olcott wrote:
>>>>> On 3/19/2024 1:31 PM, immibis wrote:
>>>>>> On 19/03/24 19:14, olcott wrote:
>>>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>>>> You are just getting nutty now. You are tossing out the
>>>>>>>>> sequence, selection, iteration model of computation.
>>>>>>>>
>>>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>>>
>>>>>>>
>>>>>>> I am only tossing out the halting problem specification.
>>>>>>> I am not saying (like Richard is saying) that sequential
>>>>>>> code can be executed out-of-sequence.
>>>>>>>
>>>>>>
>>>>>> in other words you accept the halting problem is unsolvable and
>>>>>> want to work on a different problem instead.
>>>>>
>>>>> Incorrect questions are questions defined to have no correct
>>>>> answer. Is this sentence true or false: "This sentence is not true."
>>>>> Is a concrete example of an incorrect question. A less subtle example
>>>>> is this question: Is this sentence true or false: "What time is it?"
>>>>
>>>> Right, but "Does the machine described by your input Halt?"
>>>>
>>>> DOES have a correct answer (just not the one that this H gives) so
>>>> it is a CORRECT question.
>>>>
>>>>>
>>>>> Incorrect question instances are questions defined to have no correct
>>>>> answer when posed to a specific entity.  They may have correct answers
>>>>> when posed to a different entity.
>>>>
>>>> And the fact that the entity DOESN'T give the correct answer doesn't
>>>> make the question incorrect.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> When neither YES no NO is a correct answer when posed to
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ of the above template then this is an incorrect
>>> question instance.
>>
>> One of them is the correct answer. In your x86utm example, YES is the
>> correct answer.
>>
>
> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>
> Therefore:
> Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question instance when posed to Ĥ.H.

Ĥ ⟨Ĥ⟩ halts therefore it is a correct question instance.

>
>>>
>>>>> Can Carol correctly answer “no” to this [yes/no] question?
>>>>>
>>>>> In the case of Hehner's "twisted self-reference" incorrect question
>>>>>   instances can be understood to be incorrect questions when the
>>>>>   full context of who is asked is included in the meaning of the
>>>>> question.
>>>>
>>>> Which, since you admit he CHANGES the question, his arguement fails
>>>> to be valid based on using the STRAWMAN fallacy.
>>>>
>>> It does not change the question. We are simply examining the subset
>>> cases when the question is applied to specific decider/input pairs.
>>>
>>> When posed to every entity named "Carol"
>>> the question is an {incorrect question instance}.
>>>
>>
>> Not if the question is about a different entity named Carol.
>
> Even if the question is posed to a Turing machine named Carol.
>

Not if the question posed to a Turing machine named Carol is about a
human being named Carol.

On 20/03/24 20:43, olcott wrote:
> On 3/20/2024 2:33 PM, immibis wrote:
>> On 20/03/24 20:18, olcott wrote:
>>> On 3/20/2024 2:11 PM, Fred. Zwarts wrote:
>>>> Op 20.mrt.2024 om 19:35 schreef olcott:
>>>>> On 3/20/2024 1:13 PM, Richard Damon wrote:
>>>>>> On 3/20/24 12:29 PM, olcott wrote:
>>>>>>> On 3/20/2024 11:12 AM, Richard Damon wrote:
>>>>>>>> On 3/19/24 2:14 PM, olcott wrote:
>>>>>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>>>>>> You are just getting nutty now. You are tossing out the
>>>>>>>>>>> sequence, selection, iteration model of computation.
>>>>>>>>>>
>>>>>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am only tossing out the halting problem specification.
>>>>>>>>> I am not saying (like Richard is saying) that sequential
>>>>>>>>> code can be executed out-of-sequence.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Just more of your lies.
>>>>>>>>
>>>>>>>> Where did I say "Sequential Code" can run out-of-sequence.
>>>>>>>>
>>>>>>>>
>>>>>>>> THe codes that I talk about not being in the sequence you think
>>>>>>>> are two INDEPENDENT copies of the machines.
>>>>>>>>
>>>>>>>
>>>>>>> The one that is called first is executed first.
>>>>>>
>>>>>> And I never denied that.
>>>>>>
>>>>>> But H(D,D) doesn't "Call" D(D), it simulates it.
>>>>>>
>>>>>
>>>>> Thus the steps of D(D) simulated by H come after H(D,D)
>>>>> is executed, they do not occur in parallel at the same time.
>>>>>
>>>>>> The D(D) that it simulates is a machine that has already been
>>>>>> "run", since Turing Machines are FULL computation devices that run
>>>>>> their procesisng as soon as they are created.
>>>>>>
>>>>>
>>>>> In some strawman deception argument the steps of D(D) come
>>>>> before H(D,D) is executed.
>>>>>
>>>>>> This seems something you don't understand, because you seem to
>>>>>> think that D(D) doesn't actually "run" until it is simulated.
>>>>>>
>>>>>
>>>>> The steps of the simulated D(D) are never run, they are only
>>>>> simulated.
>>>>> In a strawman deception argument the steps of D(D) are executed before
>>>>> the steps of H(D,D).
>>>>>
>>>>>>>
>>>>>>>> The H that is deciding the D(D) does not enforce that the ACTUAL
>>>>>>>> D(D) it is simulating has not been run yet, and in fact, since
>>>>>>>> we can consider Turing Machines to "auto-start" once created, it
>>>>>>>> is IMPOSSIBLE to give to H a description of a D(D) that has not
>>>>>>>> already run itself.
>>>>>>>>
>>>>>>> The one that is called first is executed first.
>>>>>>
>>>>>> So?
>>>>>>
>>>>>
>>>>> You tried to get away with saying otherwise.
>>>>>
>>>>>> Where does H call D(D)? It SIMULATES it.
>>>>>>
>>>>>> You seem to think that simulation is the exact same thing as
>>>>>> EXECUTION.
>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> Ĥ ⟨Ĥ⟩ is executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ thus the executed Ĥ ⟨Ĥ⟩ is
>>>>>>> run before the simulated one. When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ simulates its input
>>>>>>> it can see that it must abort this simulation.
>>>>>>
>>>>>> Yes H^ (H^) is executed before H^.H (H^) (H^) but the instance of
>>>>>> the machine represented by that input was executed when it was
>>>>>> created, so has already run.
>>>>>>
>>>>> Unless you are trying to get away with rejecting the sequence of
>>>>> sequence, selection, iteration you already know that Ĥ ⟨Ĥ⟩ is always
>>>>> executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>>> Again, you are confusing the simulation that H, or H^.H does, with
>>>>>> the axtual execution of them.
>>>>>>
>>>>>> You could even look at the simulation of H^.H as telling H part of
>>>>>> what this H^ (H^) has alteady done.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>>> We, as finite humans may not know what it did, but the
>>>>>>>> mathematical world of truth does.
>>>>>>>>
>>>>>>>
>>>>>>> Mathematical induction proves that after N steps of correct
>>>>>>> simulation
>>>>>>> H correctly determines that ∞ steps of correct simulation would
>>>>>>> never
>>>>>>> halt. *These are verified facts that you perpetually deny*
>>>>>>
>>>>>> NOPE.
>>>>>>
>>>>>> STATE YOUR INDUCTION CRITERIA and their proof
>>>>>>
>>>>>
>>>>> As soon as H(D,D) sees that D calls itself with its same inputs
>>>>> and there are no conditional branch instructions from the
>>>>> beginning of D to its call to H(D,D) then H knows that its
>>>>> simulated D(D) cannot possibly reach its own final instruction
>>>>> (at line 06) in any finite number of steps of correct simulation.
>>>>
>>>> An infinite recursion could be detected if a program comes back at
>>>> the same place in the same state. In this case the beginning of D
>>>> and the call to H are not the same place within the program. What
>>>> Olcott means, but does not say, is that the call from D to H causes
>>>> the program to arrive at a similar place in a similar state as when
>>>> H (not D) started. But now we see that there are conditional branch
>>>> instructions between these two places, namely within H, which may
>>>> cause an end of the recursion. In fact, it is known that the
>>>> recursion is not infinite, but does end, because H aborts and returns.
>>>
>>> There are no conditional branch instructions that allow
>>> the simulated D(D) to reach its own final state and halt.
>>
>> There is a conditional branch instruction which causes the simulated
>> H(D,D) to reach its final state and return 0. However,
>
>> the simulation of H(D,D) is aborted before the simulated H(D,D)
>> reaches this instruction.
>>
>
> That proves a lack of sufficient software engineering skills.
> What are your programming skills?
>
> I have been a professional developer since 1984 and a professional
> C++ software engineer since 2000.

Ad hominem deception rejected.

>
>>>
>>> In fact neither the simulated D(D) nor the executed H(D,D) can
>>> possibly stop running unless the executed H(D,D) aborts its
>>> simulation without waiting for any simulated H(D,D) to do this.
>>>
>>
>

On 20/03/24 20:39, olcott wrote:
> On 3/20/2024 2:32 PM, immibis wrote:
>> On 20/03/24 20:30, olcott wrote:
>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells
>>>>>>>>>>>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct
>>>>>>>>>>>>>>>>>>> abort decider then
>>>>>>>>>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>>>>>>>>>> prerequisite
>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the
>>>>>>>>>>>>>>>>>> Olcott abort problem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You can learn calculus without the basis of algebra.
>>>>>>>>>>>>>>>>> You can't learn
>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When are you going to extend this theory of simulating
>>>>>>>>>>>>>>>> abort deciders so that it solves the halting problem
>>>>>>>>>>>>>>>> instead of merely solving the Olcott abort problem?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>>>>>>>>>> incorrect question thus must be redefined.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>>>>
>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct
>>>>>>>>>>>> answer to all entities.
>>>>>>>>>>>
>>>>>>>>>>> *counter factual*
>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>
>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>
>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>
>>>>>>>
>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>> No. The H that answers 'yes' is a different H.
>>>>>
>>>>> Can D correctly simulated by H terminate normally?
>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> Every H(D,D) that does not abort its simulation input never
>>>>> stops running.
>>>>>
>>>>>> It would be correct for this D. We can build another D, based on
>>>>>> the new H, but then the question changes, because the input
>>>>>> changes. The new H does not give the correct answer for the new D.
>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>> No. The H that answers 'yes' is a different H. It would be correct
>>>>>> for this D. We can build another D, based on the new H, but then
>>>>>> the question changes, because the input changes. The new H does
>>>>>> not give the correct answer for the new D.
>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>> No. The H that answers 'yes' is a different H. It would be correct
>>>>>> for this D. We can build another D, based on the new H, but then
>>>>>> the question changes, because the input changes. The new H does
>>>>>> not give the correct answer for the new D.
>>>>>>
>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>> failed to give it. It seems Olcott is again confused, because he
>>>>>> uses the same names for different things.
>>>>>>
>>>>>
>>>>> Every H(D,D) that does not abort its simulation input never
>>>>> stops running.
>>>>>
>>>>> Trying to refer to a different H than every H is a very lame
>>>>> attempt to get away with the strawman deception.
>>>>
>>>> Very weak response. I did not say different from every H.
>>>> It seems Olcott does not understand that if he speaks about 'every
>>>> H' then not all these H are equal, but they are different. So two
>>>> examples
>>>
>>> Every H(D,D) that does not abort its simulation is exactly equal in
>>> that none of them ever stop running.
>>
>> That's not actually true. If we call
>> H_exact_simulation_that_does_not_abort(D,D) (such as qemu) we see that
>> it correctly returns 'yes', because D(D) calls H(D,D), which returns
>> 0, and then D(D) returns, and then
>> H_exact_simulation_that_does_not_abort(D,D) returns 1.
>>
>
> Every H(D,D) that does not abort its simulated input never
> stops running.

On 20/03/24 13:43, olcott wrote:
> On 3/20/2024 6:06 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 19:53 schreef olcott:
>>> On 3/19/2024 1:31 PM, immibis wrote:
>>>> On 19/03/24 19:14, olcott wrote:
>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>>>> selection, iteration model of computation.
>>>>>>
>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>
>>>>>
>>>>> I am only tossing out the halting problem specification.
>>>>> I am not saying (like Richard is saying) that sequential
>>>>> code can be executed out-of-sequence.
>>>>>
>>>>
>>>> in other words you accept the halting problem is unsolvable and want
>>>> to work on a different problem instead.
>>>
>>> Incorrect questions are questions defined to have no correct
>>> answer.
>>
>> Repeating irrelevant remarks does not change the situation.
>> Each program either halts or does not halt. So, the question "Does the
>> program specified in the input halt?" has a correct yes or no answer
>> for each program, independent of who you ask.
>> Olcott has never given any evidence that a program may exists which
>> has a third possibility. So, he never gave any evidence that it is an
>> incorrect question.
>
> Can Carol correctly answer “no” to this [yes/no] question?

Invalid question: not a sentence in first-order logic.

On 3/20/24 8:43 AM, olcott wrote:
> On 3/20/2024 6:06 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 19:53 schreef olcott:
>>> On 3/19/2024 1:31 PM, immibis wrote:
>>>> On 19/03/24 19:14, olcott wrote:
>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>>>> selection, iteration model of computation.
>>>>>>
>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>
>>>>>
>>>>> I am only tossing out the halting problem specification.
>>>>> I am not saying (like Richard is saying) that sequential
>>>>> code can be executed out-of-sequence.
>>>>>
>>>>
>>>> in other words you accept the halting problem is unsolvable and want
>>>> to work on a different problem instead.
>>>
>>> Incorrect questions are questions defined to have no correct
>>> answer.
>>
>> Repeating irrelevant remarks does not change the situation.
>> Each program either halts or does not halt. So, the question "Does the
>> program specified in the input halt?" has a correct yes or no answer
>> for each program, independent of who you ask.
>> Olcott has never given any evidence that a program may exists which
>> has a third possibility. So, he never gave any evidence that it is an
>> incorrect question.
>
> Can Carol correctly answer “no” to this [yes/no] question?
> When posed to Carol A correct answer to that question instance
> is logically impossible.

Carol isn't a deterministic Autonom, so that is just a Strawman

Like most of your better arguments.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Does Ĥ ⟨Ĥ⟩ halt?
> When posed to Ĥ.H A correct answer to that question instance
> is logically impossible.
>
> Logical impossibilities never place any actual limit on anyone
> or anything.
>
>
>> He only tries to replace the question into a different irrelevant
>> question. For the new question he gave evidence that it is an
>> incorrect question. It is not clear to me why he wants to change the
>> correct question into an incorrect question.
>>
>

On 19/03/24 19:53, olcott wrote:
> On 3/19/2024 1:31 PM, immibis wrote:
>> On 19/03/24 19:14, olcott wrote:
>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>> On 19/03/24 05:37, olcott wrote:
>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>> selection, iteration model of computation.
>>>>
>>>> aren't you tossing out the turing machine model of computation?
>>>>
>>>
>>> I am only tossing out the halting problem specification.
>>> I am not saying (like Richard is saying) that sequential
>>> code can be executed out-of-sequence.
>>>
>>
>> in other words you accept the halting problem is unsolvable and want
>> to work on a different problem instead.
>
> Incorrect questions are questions defined to have no correct
> answer. Is this sentence true or false: "This sentence is not true."
> Is a concrete example of an incorrect question. A less subtle example
> is this question: Is this sentence true or false: "What time is it?"
>
> Incorrect question instances are questions defined to have no correct
> answer when posed to a specific entity.  They may have correct answers
> when posed to a different entity.
> Can Carol correctly answer “no” to this [yes/no] question?

In other words any question which can be proven to be undecidable is not
actually undecidable because you said so.

On 3/20/2024 2:57 PM, Richard Damon wrote:
> On 3/20/24 2:07 PM, olcott wrote:

<snip>

>> Since I defined the term "incorrect question" and I defined the
>> term "incorrect question instance" I cannot possibly have defined
>> them incorrectly. These are stipulative definitions.
>> https://en.wikipedia.org/wiki/Stipulative_definition
>
> And by stipulating your definition, you havve disconnected it from any
> other use in the theory, in prticular, just because some question turns
> out to be an Olcott-Incorrect Question doesn't me it is an improper
> question to put to a decider to see if it meets its defintion.
>

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.

Therefore:
Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question instance when posed to Ĥ.H.

It is logically impossible for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide a correct answer
because every answer that Ĥ.H provides is contradicted.

If the inability to do the logically impossible was any actual
limitation then humans would be limited in that they cannot
correctly answer this question: What time is is (yes or no)?

> This seems to be something you don't understand about Stipulating your
> definitions.
>
>>
>> An {incorrect question} is any question that has no correct answer.
>> What time is it (yes or no)? is an incorrect question.
>>
> So, by YOUR definitoin, the "Halting Question", namely the question,
> "Does the Computation described by this input Halt?" is not an
> {incorrect question}, as EVERY specific computation will either Halt or
> Not.
>

Once the incorrect question instances are tossed out then it is
a correct question.

>
>> An {incorrect question instance} is any question that has no
>> correct answer from the one that this question was posed to.
>
> And, if the "one" that question was posed to, by reason of the
> "definition" of that "one" just doesn't give the correct answer, are you
> saying that is enough to make that question instance invalid?
>

When the only reason that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ fails to provide a correct
answer is that every answer is contradicted then these incorrect
question instances must be tossed out.

--
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/20/24 2:17 PM, olcott wrote:
> On 3/20/2024 1:00 PM, Richard Damon wrote:
>> On 3/19/24 2:53 PM, olcott wrote:
>>> On 3/19/2024 1:31 PM, immibis wrote:
>>>> On 19/03/24 19:14, olcott wrote:
>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>>>> selection, iteration model of computation.
>>>>>>
>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>
>>>>>
>>>>> I am only tossing out the halting problem specification.
>>>>> I am not saying (like Richard is saying) that sequential
>>>>> code can be executed out-of-sequence.
>>>>>
>>>>
>>>> in other words you accept the halting problem is unsolvable and want
>>>> to work on a different problem instead.
>>>
>>> Incorrect questions are questions defined to have no correct
>>> answer. Is this sentence true or false: "This sentence is not true."
>>> Is a concrete example of an incorrect question. A less subtle example
>>> is this question: Is this sentence true or false: "What time is it?"
>>
>> Right, but "Does the machine described by your input Halt?"
>>
>> DOES have a correct answer (just not the one that this H gives) so it
>> is a CORRECT question.
>>
>>>
>>> Incorrect question instances are questions defined to have no correct
>>> answer when posed to a specific entity.  They may have correct answers
>>> when posed to a different entity.
>>
>> And the fact that the entity DOESN'T give the correct answer doesn't
>> make the question incorrect.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> When neither YES no NO is a correct answer when posed to
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ of the above template then this is an incorrect
> question instance.

No, if the particular H / H^.H says Yes, then NO is the correct answer,
and if the particular H / H^.H says No, then Yes is the correct answer.

A given H / H^.H can only give one answer.

You are just admittting you are totally ignorant of how Programs work.

>
>>> Can Carol correctly answer “no” to this [yes/no] question?
>>>
>>> In the case of Hehner's "twisted self-reference" incorrect question
>>>   instances can be understood to be incorrect questions when the
>>>   full context of who is asked is included in the meaning of the
>>> question.
>>
>> Which, since you admit he CHANGES the question, his arguement fails to
>> be valid based on using the STRAWMAN fallacy.
>>
> It does not change the question. We are simply examining the subset
> cases when the question is applied to specific decider/input pairs.

But, that means that each pair is part of a DIFFERENT question, each of
which can have a different answer.

The fact that NONE of your selected H's get the right answer for the
input you have happened to pair them with shows that NONE of them are
correct deciders.

The fact that for every one of your Hs, there exists another decider,
H1, that gets the right answer to the question, means that BY
DEFINITION, there IS a correct answer, so the question is not incorrect.

>
> When posed to every entity named "Carol"
> the question is an {incorrect question instance}.
>

Which is a strawman, as "Carol" is a volitional being, who can get
whatever answer she wants, while the decider is a deterministic
algorithm for which its answer to the question was predetermined when it
was written.

Something you seem unable to understand, making me wonder if you have
sold your "free-will" to the devil for something, and are now trying to
break out of your deterministic life by trying to redefine determinism
to include free-will abilities.

On 3/20/24 4:11 PM, immibis wrote:
> On 19/03/24 19:53, olcott wrote:
>> On 3/19/2024 1:31 PM, immibis wrote:
>>> On 19/03/24 19:14, olcott wrote:
>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>>> selection, iteration model of computation.
>>>>>
>>>>> aren't you tossing out the turing machine model of computation?
>>>>>
>>>>
>>>> I am only tossing out the halting problem specification.
>>>> I am not saying (like Richard is saying) that sequential
>>>> code can be executed out-of-sequence.
>>>>
>>>
>>> in other words you accept the halting problem is unsolvable and want
>>> to work on a different problem instead.
>>
>> Incorrect questions are questions defined to have no correct
>> answer. Is this sentence true or false: "This sentence is not true."
>> Is a concrete example of an incorrect question. A less subtle example
>> is this question: Is this sentence true or false: "What time is it?"
>>
>> Incorrect question instances are questions defined to have no correct
>> answer when posed to a specific entity.  They may have correct answers
>> when posed to a different entity.
>> Can Carol correctly answer “no” to this [yes/no] question?
>
> In other words any question which can be proven to be undecidable is not
> actually undecidable because you said so.

Nothing wrong with a question being undecidable.

That means it must be valid, as before you can find out that a question
is undecidable, you must know that there exists a correct answer for
every input.

You seem to confuse these two things.

On 3/20/24 2:35 PM, olcott wrote:
> On 3/20/2024 1:13 PM, Richard Damon wrote:
>> On 3/20/24 12:29 PM, olcott wrote:
>>> On 3/20/2024 11:12 AM, Richard Damon wrote:
>>>> On 3/19/24 2:14 PM, olcott wrote:
>>>>> On 3/19/2024 12:42 PM, immibis wrote:
>>>>>> On 19/03/24 05:37, olcott wrote:
>>>>>>> You are just getting nutty now. You are tossing out the sequence,
>>>>>>> selection, iteration model of computation.
>>>>>>
>>>>>> aren't you tossing out the turing machine model of computation?
>>>>>>
>>>>>
>>>>> I am only tossing out the halting problem specification.
>>>>> I am not saying (like Richard is saying) that sequential
>>>>> code can be executed out-of-sequence.
>>>>>
>>>>
>>>> Just more of your lies.
>>>>
>>>> Where did I say "Sequential Code" can run out-of-sequence.
>>>>
>>>>
>>>> THe codes that I talk about not being in the sequence you think are
>>>> two INDEPENDENT copies of the machines.
>>>>
>>>
>>> The one that is called first is executed first.
>>
>> And I never denied that.
>>
>> But H(D,D) doesn't "Call" D(D), it simulates it.
>>
>
> Thus the steps of D(D) simulated by H come after H(D,D)
> is executed, they do not occur in parallel at the same time.
>
>> The D(D) that it simulates is a machine that has already been "run",
>> since Turing Machines are FULL computation devices that run their
>> procesisng as soon as they are created.
>>
>
> In some strawman deception argument the steps of D(D) come
> before H(D,D) is executed.
>
>> This seems something you don't understand, because you seem to think
>> that D(D) doesn't actually "run" until it is simulated.
>>
>
> The steps of the simulated D(D) are never run, they are only simulated.
> In a strawman deception argument the steps of D(D) are executed before
> the steps of H(D,D).

Yes, the SIMULATION of those steps come after, but the steps that are
being simmulated came before.

You seem to confuse the simulation of code with the actual running of
it, and seem to forget that to actually simulate the code, the input
needs to be fully defined, and thus the design phase considered
completed (though you may waterfall on failure to a new design cycle).

Thus, to simulate D / H^, you need to have defined H since it depends on
it, and thus the answer to H(D,D) is fixed before you run the test.

>
>>>
>>>> The H that is deciding the D(D) does not enforce that the ACTUAL
>>>> D(D) it is simulating has not been run yet, and in fact, since we
>>>> can consider Turing Machines to "auto-start" once created, it is
>>>> IMPOSSIBLE to give to H a description of a D(D) that has not already
>>>> run itself.
>>>>
>>> The one that is called first is executed first.
>>
>> So?
>>
>
> You tried to get away with saying otherwise.

Where?

The code was (automatically) run before simulation starts, in an
independent timeline.

>
>> Where does H call D(D)? It SIMULATES it.
>>
>> You seem to think that simulation is the exact same thing as EXECUTION.
>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ ⟨Ĥ⟩ is executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ thus the executed Ĥ ⟨Ĥ⟩ is
>>> run before the simulated one. When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ simulates its input
>>> it can see that it must abort this simulation.
>>
>> Yes H^ (H^) is executed before H^.H (H^) (H^) but the instance of the
>> machine represented by that input was executed when it was created, so
>> has already run.
>>
> Unless you are trying to get away with rejecting the sequence of
> sequence, selection, iteration you already know that Ĥ ⟨Ĥ⟩ is always
> executed before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

Never said otherwise, and thus the correct behavior that H^ (H^) will do
has been determined before H^ (H^) simulates it, so we have a definition
of a correct simulation, that which matches that actual behavior.

Of course, H (or H^.H) doesn't see all that behavior, so can't use that
actual behavior, only what it has seen, or can CORRECTLY deduce (which
must match what actually happened to be correct) happened when it makes
its decision.

>
>> Again, you are confusing the simulation that H, or H^.H does, with the
>> axtual execution of them.
>>
>> You could even look at the simulation of H^.H as telling H part of
>> what this H^ (H^) has alteady done.
>>
>>
>>>
>>>> We, as finite humans may not know what it did, but the mathematical
>>>> world of truth does.
>>>>
>>>
>>> Mathematical induction proves that after N steps of correct simulation
>>> H correctly determines that ∞ steps of correct simulation would never
>>> halt. *These are verified facts that you perpetually deny*
>>
>> NOPE.
>>
>> STATE YOUR INDUCTION CRITERIA and their proof
>>
>
> As soon as H(D,D) sees that D calls itself with its same inputs
> and there are no conditional branch instructions from the
> beginning of D to its call to H(D,D) then H knows that its
> simulated D(D) cannot possibly reach its own final instruction
> (at line 06) in any finite number of steps of correct simulation.

Maybe it knows that IT can simulate it to that final state, but it
doesn't know that if it aborts it, that the actual correct simulation
(which matches that actual behavior) won't halt.

So, it can do its arguement about OTHER "similar" Hs and Ds but not for
its own, which is different.

>
>>>
>>> At least you finally understand how H(D,D) != H1(D,D) after two
>>> years of failing to examine my proof that I was correct all along.
>>
>> Only because you finally admitted that H1 was a different computation,
>> and thus represent a different Turing Machine than H.
>>
>
> You simply refused to look at the one page proof that I was correct
> all along. At the time I thought that you had looked at it and simply
> denied the easily verified facts. At the time this reasonable assumption
> did justify me calling you a liar.
>

You CLAIMED it was the same computation.

I KNEW you were lying, and trying to point out your error. Of course,
since you never learned (at apparently still do not know) what a
computation actually is, you are been just lying out of your
self-imposed ignorance, making you just a pathological liar, that can't
tell truth from lies because they have lost the sense of the defintion
of Truth.

>>>
>>>> You can't seem to comprehend that world, because you seem to like to
>>>> live in your world of LIES.
>>>
>>
>
> In retrospect is looks like neither one of us are liars.
>

Mope. You are still a liar, as you continue to start your lies.

On 3/20/24 3:18 PM, olcott wrote:
> On 3/20/2024 2:11 PM, Fred. Zwarts wrote:
>> Op 20.mrt.2024 om 19:35 schreef olcott:
>>> On 3/20/2024 1:13 PM, Richard Damon wrote:
>>>> On 3/20/24 12:29 PM, olcott wrote:
>>>>> On 3/20/2024 11:12 AM, Richard Damon wrote:
>>>>>> We, as finite humans may not know what it did, but the
>>>>>> mathematical world of truth does.
>>>>>>
>>>>>
>>>>> Mathematical induction proves that after N steps of correct simulation
>>>>> H correctly determines that ∞ steps of correct simulation would never
>>>>> halt. *These are verified facts that you perpetually deny*
>>>>
>>>> NOPE.
>>>>
>>>> STATE YOUR INDUCTION CRITERIA and their proof
>>>>
>>>
>>> As soon as H(D,D) sees that D calls itself with its same inputs
>>> and there are no conditional branch instructions from the
>>> beginning of D to its call to H(D,D) then H knows that its
>>> simulated D(D) cannot possibly reach its own final instruction
>>> (at line 06) in any finite number of steps of correct simulation.
>>
>> An infinite recursion could be detected if a program comes back at the
>> same place in the same state. In this case the beginning of D and the
>> call to H are not the same place within the program. What Olcott
>> means, but does not say, is that the call from D to H causes the
>> program to arrive at a similar place in a similar state as when H (not
>> D) started. But now we see that there are conditional branch
>> instructions between these two places, namely within H, which may
>> cause an end of the recursion. In fact, it is known that the recursion
>> is not infinite, but does end, because H aborts and returns.
>
> There are no conditional branch instructions that allow
> the simulated D(D) to reach its own final state and halt.
>
> In fact neither the simulated D(D) nor the executed H(D,D) can
> possibly stop running unless the executed H(D,D) aborts its
> simulation without waiting for any simulated H(D,D) to do this.
>

So, are you claim that any machine that starts to simulate a potentially
infinite sumulation, and aborts that simulation and then Halts is
actually a non-hatling simulation because it only halted because it
aborted the simulation it was doing?

Haltng is about the machie itself, and NOT about "How" it got there.

In fact, that is a general property of the mappings that computations
generate (For Computability Theory). We don't care about HOW the
algorithm got there, just the final mapping.

Other fields, like Complexity Theory might look at the internal details,
like how many steps or how much memory it took, but Computability theory
does not.

Thus, the fact that a specific D(D) does a simulation that it aborts,
doesn't affect the answer that is halting (assuming it is built on a
specific H that does abort and return 0), and a correct simulation of
itself will end, een if THAT H decides INCORRECTLY to abort.

On 20/03/24 21:13, olcott wrote:
> On 3/20/2024 2:57 PM, Richard Damon wrote:
>> On 3/20/24 2:07 PM, olcott wrote:
>
> <snip>
>
>>> Since I defined the term "incorrect question" and I defined the
>>> term "incorrect question instance" I cannot possibly have defined
>>> them incorrectly. These are stipulative definitions.
>>> https://en.wikipedia.org/wiki/Stipulative_definition
>>
>> And by stipulating your definition, you havve disconnected it from any
>> other use in the theory, in prticular, just because some question
>> turns out to be an Olcott-Incorrect Question doesn't me it is an
>> improper question to put to a decider to see if it meets its defintion.
>>
>
> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
Right.
> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
Right.
> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
Right*
> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
Right*

Conclusion: Every halt decider is wrong in at least one instance.
Conclusion: Halt deciders are impossible to make.
Conclusion: The halting problem is not decidable.

> Therefore:
> Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question instance when posed to Ĥ.H.
Wrong.

> It is logically impossible for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide a correct answer
> because every answer that Ĥ.H provides is contradicted.
Wrong. The fact that Sally thinks 1+1=4 and Joseph thinks 2+2=2 does not
mean that 1+1=2 and 2+2=4 are incorrect.

> If the inability to do the logically impossible was any actual
> limitation then humans would be limited in that they cannot
> correctly answer this question: What time is is (yes or no)?
Humans are limited in that they cannot correctly answer this question:
What time is is (yes or no)?

>> This seems to be something you don't understand about Stipulating your
>> definitions.
>>
>>>
>>> An {incorrect question} is any question that has no correct answer.
>>> What time is it (yes or no)? is an incorrect question.
>>>
>> So, by YOUR definitoin, the "Halting Question", namely the question,
>> "Does the Computation described by this input Halt?" is not an
>> {incorrect question}, as EVERY specific computation will either Halt
>> or Not.
>>
>
> Once the incorrect question instances are tossed out then it is
> a correct question.

what the fuck is this logic

>>> An {incorrect question instance} is any question that has no
>>> correct answer from the one that this question was posed to.
>>
>> And, if the "one" that question was posed to, by reason of the
>> "definition" of that "one" just doesn't give the correct answer, are
>> you saying that is enough to make that question instance invalid?
>>
>
> When the only reason that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ fails to provide a correct
> answer is that every answer is contradicted then these incorrect
> question instances must be tossed out.

Only one answer per Ĥ is contradicted. The other answer is correct.

On 3/20/24 3:43 PM, olcott wrote:
> On 3/20/2024 2:33 PM, immibis wrote:
>> On 20/03/24 20:18, olcott wrote:
>>> On 3/20/2024 2:11 PM, Fred. Zwarts wrote:
>>>> Op 20.mrt.2024 om 19:35 schreef olcott:
>>>>> On 3/20/2024 1:13 PM, Richard Damon wrote:
>>>>>> On 3/20/24 12:29 PM, olcott wrote:
>>>>>>> Mathematical induction proves that after N steps of correct
>>>>>>> simulation
>>>>>>> H correctly determines that ∞ steps of correct simulation would
>>>>>>> never
>>>>>>> halt. *These are verified facts that you perpetually deny*
>>>>>>
>>>>>> NOPE.
>>>>>>
>>>>>> STATE YOUR INDUCTION CRITERIA and their proof
>>>>>>
>>>>>
>>>>> As soon as H(D,D) sees that D calls itself with its same inputs
>>>>> and there are no conditional branch instructions from the
>>>>> beginning of D to its call to H(D,D) then H knows that its
>>>>> simulated D(D) cannot possibly reach its own final instruction
>>>>> (at line 06) in any finite number of steps of correct simulation.
>>>>
>>>> An infinite recursion could be detected if a program comes back at
>>>> the same place in the same state. In this case the beginning of D
>>>> and the call to H are not the same place within the program. What
>>>> Olcott means, but does not say, is that the call from D to H causes
>>>> the program to arrive at a similar place in a similar state as when
>>>> H (not D) started. But now we see that there are conditional branch
>>>> instructions between these two places, namely within H, which may
>>>> cause an end of the recursion. In fact, it is known that the
>>>> recursion is not infinite, but does end, because H aborts and returns.
>>>
>>> There are no conditional branch instructions that allow
>>> the simulated D(D) to reach its own final state and halt.
>>
>> There is a conditional branch instruction which causes the simulated
>> H(D,D) to reach its final state and return 0. However,
>
>> the simulation of H(D,D) is aborted before the simulated H(D,D)
>> reaches this instruction.
>>
>
> That proves a lack of sufficient software engineering skills.
> What are your programming skills?
>
> I have been a professional developer since 1984 and a professional
> C++ software engineer since 2000.

Which seems to say that you were actually a FAILED programmer. or are
just a pathological liar.

Where did you get the criteria that doesn't need to look at the FULL
loop from starting at the call to H(D,D) around to when its simulation
of D(D) calls H(D,D) again?

You are just proven to be making up your "facts", because you don't
understand what "Truth" actually is.

>
>>>
>>> In fact neither the simulated D(D) nor the executed H(D,D) can
>>> possibly stop running unless the executed H(D,D) aborts its
>>> simulation without waiting for any simulated H(D,D) to do this.
>>>
>>
>

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.

Since your H(D,D) aborts and says NO, it can't say YES, as programs do
what they do.

An H that says Yes, needs to be a DIFFERENT H, and either you are
creating a NEW H^ for it to get wrong, or you give it this H^, and it
will end up being right.

You just don't seem to understand that fundamental property that
programs do what they do and not what they do not, and changing them
changes them into something new.

>
>>
>>>> Please show some EXACT input that doesn't have a correct answer.
>>
>

On 3/20/24 12:11 PM, olcott wrote:
> 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, because D uses THIS H, not the changed one.

Are you THAT stupid?

Or, are you admitting that your D isn't built by the Linz template and
everythig you have done is a LIE?

> *That would cause D(D) to loop, thus wrong answer*
> *That would cause D(D) to loop, thus wrong answer*
>
> Can D correctly simulated by H terminate normally?
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)

Which happens, so unsound logic follows.

> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.

Nope, only true if H never aborts, so UNSOUND logic follows.

>
> All halt deciders must compute the mapping from the behavior that its
> finite string specifies... D specifies that N to ∞ steps of D correctly
> simulated by H cannot possibly reach the final state of D at line (6),
> thus D specifies non-halting behavior.
>

Nope, H only test ONE value of N, and thus DOES halt at a larger value
then H tests.

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.

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