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

Read it this time:
*As I already said: If H is is allowed to cheat the way that you and*
*Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
*halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.

Read it this time:
*As I already said: If H is is allowed to cheat the way that you and*
*Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
*halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.

Read it this time:
*As I already said: If H is is allowed to cheat the way that you and*
*Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
*halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.

Read it this time:
*As I already said: If H is is allowed to cheat the way that you and*
*Mike proposed and have different behavior than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ then the*
*halting problem proof fails because H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the correct *answer.

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

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

On 3/21/2024 11:57 PM, immibis wrote:
> On 22/03/24 05:29, olcott wrote:
>> On 3/21/2024 11:20 PM, immibis wrote:
>>> On 22/03/24 04:50, olcott wrote:
>>>> On 3/21/2024 10:43 PM, immibis wrote:
>>>>> On 21/03/24 19:31, olcott wrote:
>>>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>>>> On 21/03/24 05:34, olcott wrote:
>>>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>>>>>> On 20/03/24 23:52, olcott wrote:
>>>>>>>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if it tells whether the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves
>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem instead of merely solving
>>>>>>>>>>>>>>>>>>>>>>>>>>> the Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct
>>>>>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be
>>>>>>>>>>>>>>>>>>>>>>>>>> redefined.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting
>>>>>>>>>>>>>>>>>>>>>>>>> Question.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this
>>>>>>>>>>>>>>>>>>>>>>>> second entity.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is
>>>>>>>>>>>>>>>>>>> "yes".
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It would be correct for this D. We can build another D,
>>>>>>>>>>>>>>>>> based on the new H, but then the question changes,
>>>>>>>>>>>>>>>>> because the input changes. The new H does not give the
>>>>>>>>>>>>>>>>> correct answer for the new D.
>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>>>> input changes. The new H does not give the correct
>>>>>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>>>> input changes. The new H does not give the correct
>>>>>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems Olcott is
>>>>>>>>>>>>>>>>> again confused, because he uses the same names for
>>>>>>>>>>>>>>>>> different things.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Trying to refer to a different H than every H is a very
>>>>>>>>>>>>>>>> lame
>>>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Referring to a different D then the one you were given is
>>>>>>>>>>>>>>> a very lame attempt to get away with a strawman deception.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>>>>>>>> implementations of H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you are still talking about the Linz proof instead of
>>>>>>>>>>>>> some bullshit, every D is based on exactly one H. If you
>>>>>>>>>>>>> change H but don't change D, the D is still based on the
>>>>>>>>>>>>> old H and the correct answer to the question "Does D(D)
>>>>>>>>>>>>> halt?" does not change.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>> 02 {
>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>> 07 }
>>>>>>>>>>>> 08
>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>> 10 {
>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>> 12 }
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Your question is meaningless.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Software engineering forums disagree.
>>>>>>>>>>
>>>>>>>>> Then they are stupid. Obviously this question cannot be
>>>>>>>>> answered without seeing the exact code of H, and then there is
>>>>>>>>> also the question about what "correctly simulated" and
>>>>>>>>> "terminate normally" mean.
>>>>>>>>
>>>>>>>> The code is available.
>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>
>>>>>>>> It Simulates according to the c source code.
>>>>>>>> Few people understand x86 assembly langugae.
>>>>>>>
>>>>>>> You cheat the halting problem because D is not a complete
>>>>>>> program, it can specify anything and everything, including making
>>>>>>> mashed potatoes.
>>>>>>
>>>>>> D is precisely isomorphic to the Strachey P.
>>>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>>>
>>>>> The Strachey P is a very short illustration of the problem which
>>>>> does not explain the details. It gets the main point across in a
>>>>> very short space, but only the main point and not the details.
>>>>> Because it does not explain the details it cannot be relied on to
>>>>> be correct in detail.
>>>>
>>>> The only relevant detail is the same as my H(D,D) != Halts(D,D)
>>>> because every return value is contradicted.
>>>>
>>> In other words, every return value is wrong.
>>
>> The correct return value is contradicted making
>> a correct return value a logical impossibility.
>
> That's right! Every program answers the wrong halting value at least
> once so it doesn't decide halting.
>

On 2024-03-22 03:21:57 +0000, olcott said:

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

On 2024-03-21 18:05:47 +0000, immibis said:

> On 21/03/24 15:11, olcott wrote:
>> Yet you did not fully address the key point: The inability to do
>> the logically impossible does not place any actual limit on anyone
>> or anything.
>
> In other words you are able to draw a square circle.
>
>> *All logical impossibilities are equivalent*
>
> In other words your inability to draw a square circle is equivalent to
> your inability to eat 500 pizzas in 3 minutes.

Are you sure the later is logically impossible for someone whose
mouth is bigger than brain?

--
Mikko

On 2024-03-21 16:34:02 +0000, olcott said:

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

On 2024-03-21 16:39:52 +0000, olcott said:

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

On 2024-03-21 18:26:44 +0000, olcott said:

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

On 2024-03-22 04:20:13 +0000, immibis said:

> On 22/03/24 04:50, olcott wrote:
>> On 3/21/2024 10:43 PM, immibis wrote:
>>> On 21/03/24 19:31, olcott wrote:
>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>> On 21/03/24 05:34, olcott wrote:
>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>>>> On 20/03/24 23:52, olcott wrote:
>>>>>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether the direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of simulating abort deciders
>>>>>>>>>>>>>>>>>>>>>>>>> so that it solves the halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
>>>>>>>>>>>>>>>>>>>>>>>> question thus must be redefined.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct answer to all
>>>>>>>>>>>>>>>>>>>>> entities.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would be correct for this D. We can build another D, based on the
>>>>>>>>>>>>>>> new H, but then the question changes, because the input changes. The
>>>>>>>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
>>>>>>>>>>>>>>> this D. We can build another D, based on the new H, but then the
>>>>>>>>>>>>>>> question changes, because the input changes. The new H does not give
>>>>>>>>>>>>>>> the correct answer for the new D.
>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
>>>>>>>>>>>>>>> this D. We can build another D, based on the new H, but then the
>>>>>>>>>>>>>>> question changes, because the input changes. The new H does not give
>>>>>>>>>>>>>>> the correct answer for the new D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Both questions have a correct answer, but the corresponding H failed to
>>>>>>>>>>>>>>> give it. It seems Olcott is again confused, because he uses the same
>>>>>>>>>>>>>>> names for different things.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Referring to a different D then the one you were given is a very lame
>>>>>>>>>>>>> attempt to get away with a strawman deception.
>>>>>>>>>>>>
>>>>>>>>>>>> I am specifying a single D and an infinite set of implementations of H.
>>>>>>>>>>>
>>>>>>>>>>> If you are still talking about the Linz proof instead of some bullshit,
>>>>>>>>>>> every D is based on exactly one H. If you change H but don't change D,
>>>>>>>>>>> the D is still based on the old H and the correct answer to the
>>>>>>>>>>> question "Does D(D) halt?" does not change.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Your question is meaningless.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Software engineering forums disagree.
>>>>>>>>
>>>>>>> Then they are stupid. Obviously this question cannot be answered
>>>>>>> without seeing the exact code of H, and then there is also the question
>>>>>>> about what "correctly simulated" and "terminate normally" mean.
>>>>>>
>>>>>> The code is available.
>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>
>>>>>> It Simulates according to the c source code.
>>>>>> Few people understand x86 assembly langugae.
>>>>>
>>>>> You cheat the halting problem because D is not a complete program, it
>>>>> can specify anything and everything, including making mashed potatoes.
>>>>
>>>> D is precisely isomorphic to the Strachey P.
>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>
>>> The Strachey P is a very short illustration of the problem which does
>>> not explain the details. It gets the main point across in a very short
>>> space, but only the main point and not the details. Because it does not
>>> explain the details it cannot be relied on to be correct in detail.
>>
>> The only relevant detail is the same as my H(D,D) != Halts(D,D)
>> because every return value is contradicted.
>>
> In other words, every return value is wrong.

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

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

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

On 3/22/2024 2:51 AM, Mikko wrote:
> On 2024-03-21 16:39:52 +0000, olcott said:
>
>> On 3/21/2024 11:29 AM, Mikko wrote:
>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>
>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>
>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it
>>>>>>>>>>>>>>>>>>>>>>>>> tells whether the direct execution of its input
>>>>>>>>>>>>>>>>>>>>>>>>> would halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct
>>>>>>>>>>>>>>>>>>>>>>>> abort decider then
>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that requires
>>>>>>>>>>>>>>>>>>>>>>>> the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem,
>>>>>>>>>>>>>>>>>>>>>>> not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the
>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer
>>>>>>>>>>>>>>>>>>>> to an incorrect question thus must be redefined.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second
>>>>>>>>>>>>>>>>>> entity.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>
>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>>> on the new H, but then the question changes, because the
>>>>>>>>>>> input changes. The new H does not give the correct answer for
>>>>>>>>>>> the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>
>>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>
>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>> It seems Olcott does not understand that if he speaks about
>>>>>>>>> 'every H' then not all these H are equal, but they are
>>>>>>>>> different. So two examples
>>>>>>>>
>>>>>>>> Every H(D,D) that does not abort its simulation is exactly equal in
>>>>>>>> that none of them ever stop running.
>>>>>>>
>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>
>>>>>>
>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>> before we move on to the next step of the analysis.
>>>>>
>>>>> Perhaps you must. Others needn't.
>>>>>
>>>>
>>>> Until this is understood one lacks the sufficient prerequisites to
>>>> comprehend any further elaborations.
>>>>
>>>> If an honest dialogue is the goal then points of mutual agreement
>>>> must be reached.
>>>>
>>>> I admitted that I was wrong about the details of some things:
>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>> exact same H. I was wrong when I said that it could.
>>>>
>>>> *This provides evidence that I want an honest dialogue*
>>>
>>> In sufficient as you have provided much more contrary evidence.
>>> No honest dialogue can be reasonable expected when you participate.
>>>
>>
>> *See if you can rebut this with reasoning instead of rhetoric*
>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>
> I just note that you have rebutted nothing wirh reasoning or rhetoric.
>

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

On 3/22/2024 3:08 AM, Mikko wrote:
> On 2024-03-22 04:20:13 +0000, immibis said:
>
>> On 22/03/24 04:50, olcott wrote:
>>> On 3/21/2024 10:43 PM, immibis wrote:
>>>> On 21/03/24 19:31, olcott wrote:
>>>>> On 3/21/2024 12:31 PM, immibis wrote:
>>>>>> On 21/03/24 05:34, olcott wrote:
>>>>>>> On 3/20/2024 11:19 PM, immibis wrote:
>>>>>>>> On 21/03/24 04:56, olcott wrote:
>>>>>>>>> On 3/20/2024 10:52 PM, immibis wrote:
>>>>>>>>>> On 20/03/24 23:52, olcott wrote:
>>>>>>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves
>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem instead of merely solving
>>>>>>>>>>>>>>>>>>>>>>>>>> the Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct
>>>>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be
>>>>>>>>>>>>>>>>>>>>>>>>> redefined.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting
>>>>>>>>>>>>>>>>>>>>>>>> Question.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this
>>>>>>>>>>>>>>>>>>>>>>> second entity.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It would be correct for this D. We can build another D,
>>>>>>>>>>>>>>>> based on the new H, but then the question changes,
>>>>>>>>>>>>>>>> because the input changes. The new H does not give the
>>>>>>>>>>>>>>>> correct answer for the new D.
>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>>> input changes. The new H does not give the correct
>>>>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would
>>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on
>>>>>>>>>>>>>>>> the new H, but then the question changes, because the
>>>>>>>>>>>>>>>> input changes. The new H does not give the correct
>>>>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems Olcott is
>>>>>>>>>>>>>>>> again confused, because he uses the same names for
>>>>>>>>>>>>>>>> different things.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Referring to a different D then the one you were given is
>>>>>>>>>>>>>> a very lame attempt to get away with a strawman deception.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>>>>>>> implementations of H.
>>>>>>>>>>>>
>>>>>>>>>>>> If you are still talking about the Linz proof instead of
>>>>>>>>>>>> some bullshit, every D is based on exactly one H. If you
>>>>>>>>>>>> change H but don't change D, the D is still based on the old
>>>>>>>>>>>> H and the correct answer to the question "Does D(D) halt?"
>>>>>>>>>>>> does not change.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>> 08
>>>>>>>>>>> 09 void main()
>>>>>>>>>>> 10 {
>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>> 12 }
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Your question is meaningless.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Software engineering forums disagree.
>>>>>>>>>
>>>>>>>> Then they are stupid. Obviously this question cannot be answered
>>>>>>>> without seeing the exact code of H, and then there is also the
>>>>>>>> question about what "correctly simulated" and "terminate
>>>>>>>> normally" mean.
>>>>>>>
>>>>>>> The code is available.
>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>
>>>>>>> It Simulates according to the c source code.
>>>>>>> Few people understand x86 assembly langugae.
>>>>>>
>>>>>> You cheat the halting problem because D is not a complete program,
>>>>>> it can specify anything and everything, including making mashed
>>>>>> potatoes.
>>>>>
>>>>> D is precisely isomorphic to the Strachey P.
>>>>> https://academic.oup.com/comjnl/article/7/4/313/354243
>>>>
>>>> The Strachey P is a very short illustration of the problem which
>>>> does not explain the details. It gets the main point across in a
>>>> very short space, but only the main point and not the details.
>>>> Because it does not explain the details it cannot be relied on to be
>>>> correct in detail.
>>>
>>> The only relevant detail is the same as my H(D,D) != Halts(D,D)
>>> because every return value is contradicted.
>>>
>> In other words, every return value is wrong.
>
> Not every return value, just the one for the input D,D.
> That suffices to prove that H is not a halt decider.
> H(X,Y) == Halts(X,Y) for some X,Y.
>

On 2024-03-22 15:41:40 +0000, olcott said:

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

On 2024-03-22 15:44:35 +0000, olcott said:

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

On 2024-03-22 15:43:49 +0000, olcott said:

> On 3/22/2024 2:51 AM, Mikko wrote:
>> On 2024-03-21 16:39:52 +0000, olcott said:
>>
>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>
>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>
>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether the direct
>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of simulating abort deciders
>>>>>>>>>>>>>>>>>>>>>> so that it solves the halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
>>>>>>>>>>>>>>>>>>>>> question thus must be redefined.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct answer to all
>>>>>>>>>>>>>>>>>> entities.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>
>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>> 08
>>>>>>>>>>> 09 void main()
>>>>>>>>>>> 10 {
>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>> 12 }
>>>>>>>>>>>
>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>> stops running.
>>>>>>>>>>>
>>>>>>>>>>>> It would be correct for this D. We can build another D, based on the
>>>>>>>>>>>> new H, but then the question changes, because the input changes. The
>>>>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
>>>>>>>>>>>> this D. We can build another D, based on the new H, but then the
>>>>>>>>>>>> question changes, because the input changes. The new H does not give
>>>>>>>>>>>> the correct answer for the new D.
>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
>>>>>>>>>>>> this D. We can build another D, based on the new H, but then the
>>>>>>>>>>>> question changes, because the input changes. The new H does not give
>>>>>>>>>>>> the correct answer for the new D.
>>>>>>>>>>>>
>>>>>>>>>>>> Both questions have a correct answer, but the corresponding H failed to
>>>>>>>>>>>> give it. It seems Olcott is again confused, because he uses the same
>>>>>>>>>>>> names for different things.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>> stops running.
>>>>>>>>>>>
>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>
>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
>>>>>>>>>> then not all these H are equal, but they are different. So two examples
>>>>>>>>>
>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly equal in
>>>>>>>>> that none of them ever stop running.
>>>>>>>>
>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>
>>>>>>>
>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>> before we move on to the next step of the analysis.
>>>>>>
>>>>>> Perhaps you must. Others needn't.
>>>>>>
>>>>>
>>>>> Until this is understood one lacks the sufficient prerequisites to
>>>>> comprehend any further elaborations.
>>>>>
>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>> must be reached.
>>>>>
>>>>> I admitted that I was wrong about the details of some things:
>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>> exact same H. I was wrong when I said that it could.
>>>>>
>>>>> *This provides evidence that I want an honest dialogue*
>>>>
>>>> In sufficient as you have provided much more contrary evidence.
>>>> No honest dialogue can be reasonable expected when you participate.
>>>>
>>>
>>> *See if you can rebut this with reasoning instead of rhetoric*
>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>
>> I just note that you have rebutted nothing wirh reasoning or rhetoric.
>>
>
> Dogmatic statements do not count as reasoning.

On 2024-03-22 15:43:04 +0000, olcott said:

> On 3/22/2024 2:50 AM, Mikko wrote:
>> On 2024-03-21 16:34:02 +0000, olcott said:
>>
>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>
>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>
>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether the direct
>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of simulating abort deciders
>>>>>>>>>>>>>>>>>>>>>> so that it solves the halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
>>>>>>>>>>>>>>>>>>>>> question thus must be redefined.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the correct answer to all
>>>>>>>>>>>>>>>>>> entities.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>
>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>> 08
>>>>>>>>>>> 09 void main()
>>>>>>>>>>> 10 {
>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>> 12 }
>>>>>>>>>>>
>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>> stops running.
>>>>>>>>>>>
>>>>>>>>>>>> It would be correct for this D. We can build another D, based on the
>>>>>>>>>>>> new H, but then the question changes, because the input changes. The
>>>>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
>>>>>>>>>>>> this D. We can build another D, based on the new H, but then the
>>>>>>>>>>>> question changes, because the input changes. The new H does not give
>>>>>>>>>>>> the correct answer for the new D.
>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
>>>>>>>>>>>> this D. We can build another D, based on the new H, but then the
>>>>>>>>>>>> question changes, because the input changes. The new H does not give
>>>>>>>>>>>> the correct answer for the new D.
>>>>>>>>>>>>
>>>>>>>>>>>> Both questions have a correct answer, but the corresponding H failed to
>>>>>>>>>>>> give it. It seems Olcott is again confused, because he uses the same
>>>>>>>>>>>> names for different things.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>> stops running.
>>>>>>>>>>>
>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>
>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
>>>>>>>>>> then not all these H are equal, but they are different. So two examples
>>>>>>>>>
>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly equal in
>>>>>>>>> that none of them ever stop running.
>>>>>>>>
>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>
>>>>>>>
>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>> before we move on to the next step of the analysis.
>>>>>>
>>>>>> Perhaps you must. Others needn't.
>>>>>>
>>>>>
>>>>> Until this is understood one lacks the sufficient prerequisites to
>>>>> comprehend any further elaborations.
>>>>>
>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>> must be reached.
>>>>>
>>>>> I admitted that I was wrong about the details of some things:
>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>> exact same H. I was wrong when I said that it could.
>>>>>
>>>>> *This provides evidence that I want an honest dialogue*
>>>>
>>>> In sufficient as you have provided much more contrary evidence.
>>>> No honest dialogue can be reasonable expected when you participate.
>>>>
>>>
>>> In other words you misconstrue rhetoric as a kind of reasoning
>>> that can be applied to rebutting logical arguments.
>>
>> I misconstrue nothong you say as any kind of reasoning.
>>
>
> Yet can't correctly point out any errors.

On 2024-03-22 15:41:40 +0000, olcott said:

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

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

On 3/22/2024 1:32 PM, Mikko wrote:
> On 2024-03-22 15:43:49 +0000, olcott said:
>
>> On 3/22/2024 2:51 AM, Mikko wrote:
>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>
>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>
>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it
>>>>>>>>>>>>>>>>>>>>>>>>>>> tells whether the direct execution of its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a
>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that
>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem,
>>>>>>>>>>>>>>>>>>>>>>>>> not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the
>>>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct
>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be
>>>>>>>>>>>>>>>>>>>>>> redefined.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting
>>>>>>>>>>>>>>>>>>>>> Question.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second
>>>>>>>>>>>>>>>>>>>> entity.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> <are>
>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>
>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>> 02 {
>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>> 07 }
>>>>>>>>>>>> 08
>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>> 10 {
>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>> 12 }
>>>>>>>>>>>>
>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>> stops running.
>>>>>>>>>>>>
>>>>>>>>>>>>> It would be correct for this D. We can build another D,
>>>>>>>>>>>>> based on the new H, but then the question changes, because
>>>>>>>>>>>>> the input changes. The new H does not give the correct
>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>>>> correct for this D. We can build another D, based on the
>>>>>>>>>>>>> new H, but then the question changes, because the input
>>>>>>>>>>>>> changes. The new H does not give the correct answer for the
>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>>>> correct for this D. We can build another D, based on the
>>>>>>>>>>>>> new H, but then the question changes, because the input
>>>>>>>>>>>>> changes. The new H does not give the correct answer for the
>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Both questions have a correct answer, but the corresponding
>>>>>>>>>>>>> H failed to give it. It seems Olcott is again confused,
>>>>>>>>>>>>> because he uses the same names for different things.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>> stops running.
>>>>>>>>>>>>
>>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>
>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>> It seems Olcott does not understand that if he speaks about
>>>>>>>>>>> 'every H' then not all these H are equal, but they are
>>>>>>>>>>> different. So two examples
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly
>>>>>>>>>> equal in
>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>
>>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>
>>>>>>> Perhaps you must. Others needn't.
>>>>>>>
>>>>>>
>>>>>> Until this is understood one lacks the sufficient prerequisites to
>>>>>> comprehend any further elaborations.
>>>>>>
>>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>>> must be reached.
>>>>>>
>>>>>> I admitted that I was wrong about the details of some things:
>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>
>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>
>>>>> In sufficient as you have provided much more contrary evidence.
>>>>> No honest dialogue can be reasonable expected when you participate.
>>>>>
>>>>
>>>> *See if you can rebut this with reasoning instead of rhetoric*
>>>> [Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
>>>
>>> I just note that you have rebutted nothing wirh reasoning or rhetoric.
>>>
>>
>> Dogmatic statements do not count as reasoning.
>
> Dgmatic statements likn "Dogmatic statements do not count as reasoning"
> do count as rhetoric.
>
> Observation of a fact is does not count as dogmatic.
>

On 3/22/2024 1:35 PM, Mikko wrote:
> On 2024-03-22 15:43:04 +0000, olcott said:
>
>> On 3/22/2024 2:50 AM, Mikko wrote:
>>> On 2024-03-21 16:34:02 +0000, olcott said:
>>>
>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>
>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it
>>>>>>>>>>>>>>>>>>>>>>>>>>> tells whether the direct execution of its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a
>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that
>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the halting problem,
>>>>>>>>>>>>>>>>>>>>>>>>> not the Olcott abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the basis of
>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of
>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this theory of
>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the
>>>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the
>>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct
>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be
>>>>>>>>>>>>>>>>>>>>>> redefined.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the Halting
>>>>>>>>>>>>>>>>>>>>> Question.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second
>>>>>>>>>>>>>>>>>>>> entity.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes" is the
>>>>>>>>>>>>>>>>>>> correct answer to all entities.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What is true is true even when contradicted by a liar.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> <are>
>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>
>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>> 02 {
>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>> 07 }
>>>>>>>>>>>> 08
>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>> 10 {
>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>> 12 }
>>>>>>>>>>>>
>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>> stops running.
>>>>>>>>>>>>
>>>>>>>>>>>>> It would be correct for this D. We can build another D,
>>>>>>>>>>>>> based on the new H, but then the question changes, because
>>>>>>>>>>>>> the input changes. The new H does not give the correct
>>>>>>>>>>>>> answer for the new D.
>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>>>> correct for this D. We can build another D, based on the
>>>>>>>>>>>>> new H, but then the question changes, because the input
>>>>>>>>>>>>> changes. The new H does not give the correct answer for the
>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>>>> correct for this D. We can build another D, based on the
>>>>>>>>>>>>> new H, but then the question changes, because the input
>>>>>>>>>>>>> changes. The new H does not give the correct answer for the
>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Both questions have a correct answer, but the corresponding
>>>>>>>>>>>>> H failed to give it. It seems Olcott is again confused,
>>>>>>>>>>>>> because he uses the same names for different things.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>>>> stops running.
>>>>>>>>>>>>
>>>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>
>>>>>>>>>>> Very weak response. I did not say different from every H.
>>>>>>>>>>> It seems Olcott does not understand that if he speaks about
>>>>>>>>>>> 'every H' then not all these H are equal, but they are
>>>>>>>>>>> different. So two examples
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation is exactly
>>>>>>>>>> equal in
>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>
>>>>>>>>> True but not very relevant as none of them is a halt decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>
>>>>>>> Perhaps you must. Others needn't.
>>>>>>>
>>>>>>
>>>>>> Until this is understood one lacks the sufficient prerequisites to
>>>>>> comprehend any further elaborations.
>>>>>>
>>>>>> If an honest dialogue is the goal then points of mutual agreement
>>>>>> must be reached.
>>>>>>
>>>>>> I admitted that I was wrong about the details of some things:
>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>
>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>
>>>>> In sufficient as you have provided much more contrary evidence.
>>>>> No honest dialogue can be reasonable expected when you participate.
>>>>>
>>>>
>>>> In other words you misconstrue rhetoric as a kind of reasoning
>>>> that can be applied to rebutting logical arguments.
>>>
>>> I misconstrue nothong you say as any kind of reasoning.
>>>
>>
>> Yet can't correctly point out any errors.
>
> It is sufficient to note that you claim that various proofs are
> erroneous without pointing out any errors.
>

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