On 3/21/24 11:25 PM, olcott wrote:
> On 3/21/2024 10:11 PM, Richard Damon wrote:
>> On 3/21/24 9:55 AM, olcott wrote:

>>> What H(D,D) returns is out-of-scope for this post.
>>
>> WHY?
>>
>
> Because you continue to fail acknowledge the self-evident-truth
> that H(D,D) does correctly determine the abort status of its input.
> *It seems like you are playing head games on this*
>

Except that is just another of your DAMNED LIES from the DAMNED LIAR,
because you have AGREED that H did NOT correctly determine the abort
status of its input, because the actual correct simulation of this input
will halt, thus H did NOT correctly determine the need to abort status.

On 3/21/24 11:55 PM, olcott wrote:

> The purpose of the C code is to extrapolate what an isomorphic
> machine would do if it had unlimited memory. It would have no
> reason to crash.
>

But all it actually does is show you don't understand what that means.

There is no way to actually build the decider input in the manner you do.

On 3/22/24 12:27 AM, olcott wrote:
> On 3/21/2024 10:10 PM, Richard Damon wrote:
>>
>> Right, and that H fails to be a decider.
>>
>> But if H does abort it simulation, then the fact that the other instances
>
> Can't be the ones to abort because every H has the same machine-code
> thus the executed H cannot wait for simulated H(D,D) to abort or no H
> would ever abort. Your software engineering skill must be pretty weak.
>

How is "Every H" the same machine code?

I think you are confusing your lies.

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

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

On 3/22/2024 9:17 PM, Richard Damon wrote:
> On 3/22/24 12:27 AM, olcott wrote:
>> On 3/21/2024 10:10 PM, Richard Damon wrote:
>>>
>>> Right, and that H fails to be a decider.
>>>
>>> But if H does abort it simulation, then the fact that the other
>>> instances
>>
>> Can't be the ones to abort because every H has the same machine-code
>> thus the executed H cannot wait for simulated H(D,D) to abort or no H
>> would ever abort. Your software engineering skill must be pretty weak.
>>
>
> How is "Every H" the same machine code?
>

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

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

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

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

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

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

On 23/03/24 02:31, olcott wrote:
> On 3/22/2024 7:44 PM, immibis wrote:
>> On 22/03/24 22:22, olcott wrote:
>>> On 3/22/2024 4:17 PM, immibis wrote:
>>>> On 22/03/24 22:01, olcott wrote:
>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>> On 22/03/24 20:49, olcott wrote:
>>>>>>> The false assumption that a halt decider must report on behavior
>>>>>>> that is different than the behavior that it actually sees.
>>>>>>>
>>>>>> That is a true assumption. That is the specification of a halt
>>>>>> decider. It must report whether a program would ever halt even
>>>>>> though it cannot see whether a program would ever halt.
>>>>>
>>>>> That contradicts the correct definition of a decider that
>>>>> must compute the mapping from its input on the basis of a
>>>>> (in this case semantic) property of this input.
>>>>
>>>> It does not contradict.
>>>>
>>>>> Since D does specify non-halting behavior to H then H(D,D)
>>>>> is necessarily correct to reject this input as non-halting.
>>>>
>>>> D specifies a program which halts when executed.
>>>
>>> That the simulation of D must be aborted by H to prevent its own
>>> infinite execution
>>
>> You think this phrase means something different to what everyone else
>> thinks it means. Therefore I recommend not using it.
>>
>
> On 3/20/2024 6:02 PM, Richard Damon wrote:
> > On 3/20/24 6:01 PM, olcott wrote:
> >> Every H(D,D) that doesn't abort its simulated input
> >> never stops running.
> >
> > Yep, shows that H's that don't abort the D built on
> > them won't be deciders...
>
How is that a rebuttal to what I said?

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

Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?

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

Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?

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

Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?

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

Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?
Read it this time:
WHAT IS CHEATING?

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

On 2024-03-22 18:50:17 +0000, olcott said:

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

On 2024-03-22 19:49:09 +0000, olcott said:

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

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

> On 3/22/2024 4:17 PM, immibis wrote:
>> On 22/03/24 22:01, olcott wrote:
>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>> On 22/03/24 20:49, olcott wrote:
>>>>> The false assumption that a halt decider must report on behavior
>>>>> that is different than the behavior that it actually sees.
>>>>>
>>>> That is a true assumption. That is the specification of a halt decider.
>>>> It must report whether a program would ever halt even though it cannot
>>>> see whether a program would ever halt.
>>>
>>> That contradicts the correct definition of a decider that
>>> must compute the mapping from its input on the basis of a
>>> (in this case semantic) property of this input.
>>
>> It does not contradict.
>>
>>> Since D does specify non-halting behavior to H then H(D,D)
>>> is necessarily correct to reject this input as non-halting.
>>
>> D specifies a program which halts when executed.
>
> That the simulation of D must be aborted by H to prevent its own
> infinite execution conclusively proves that D specifies non-halting
> behavior to H. *The only "rebuttals" to this are damned lies*

Linz and many others have proven that there are no halt deciders.
Olcott's only "rebuttals" to this are damned lies.

--
Mikko

On 2024-03-22 18:45:01 +0000, olcott said:

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

On 2024-03-22 18:43:39 +0000, olcott said:

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

On 3/23/2024 2:22 AM, immibis wrote:
> On 23/03/24 02:31, olcott wrote:
>> On 3/22/2024 7:44 PM, immibis wrote:
>>> On 22/03/24 22:22, olcott wrote:
>>>> On 3/22/2024 4:17 PM, immibis wrote:
>>>>> On 22/03/24 22:01, olcott wrote:
>>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>>> On 22/03/24 20:49, olcott wrote:
>>>>>>>> The false assumption that a halt decider must report on behavior
>>>>>>>> that is different than the behavior that it actually sees.
>>>>>>>>
>>>>>>> That is a true assumption. That is the specification of a halt
>>>>>>> decider. It must report whether a program would ever halt even
>>>>>>> though it cannot see whether a program would ever halt.
>>>>>>
>>>>>> That contradicts the correct definition of a decider that
>>>>>> must compute the mapping from its input on the basis of a
>>>>>> (in this case semantic) property of this input.
>>>>>
>>>>> It does not contradict.
>>>>>
>>>>>> Since D does specify non-halting behavior to H then H(D,D)
>>>>>> is necessarily correct to reject this input as non-halting.
>>>>>
>>>>> D specifies a program which halts when executed.
>>>>
>>>> That the simulation of D must be aborted by H to prevent its own
>>>> infinite execution
>>>
>>> You think this phrase means something different to what everyone else
>>> thinks it means. Therefore I recommend not using it.
>>>
>>
>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>  > On 3/20/24 6:01 PM, olcott wrote:
>>  >> Every H(D,D) that doesn't abort its simulated input
>>  >> never stops running.
>>  >
>>  > Yep, shows that H's that don't abort the D built on
>>  > them won't be deciders...
>>
> How is that a rebuttal to what I said?

If you can't tell then you aren't honest.

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

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

In other words you forgot your own words that I refer to?
Every H must have identical behavior, You and Mike proposed otherwise.
That is cheating.

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

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

On 3/23/2024 6:07 AM, Mikko wrote:
> On 2024-03-22 21:22:55 +0000, olcott said:
>
>> On 3/22/2024 4:17 PM, immibis wrote:
>>> On 22/03/24 22:01, olcott wrote:
>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>> On 22/03/24 20:49, olcott wrote:
>>>>>> The false assumption that a halt decider must report on behavior
>>>>>> that is different than the behavior that it actually sees.
>>>>>>
>>>>> That is a true assumption. That is the specification of a halt
>>>>> decider. It must report whether a program would ever halt even
>>>>> though it cannot see whether a program would ever halt.
>>>>
>>>> That contradicts the correct definition of a decider that
>>>> must compute the mapping from its input on the basis of a
>>>> (in this case semantic) property of this input.
>>>
>>> It does not contradict.
>>>
>>>> Since D does specify non-halting behavior to H then H(D,D)
>>>> is necessarily correct to reject this input as non-halting.
>>>
>>> D specifies a program which halts when executed.
>>
>> That the simulation of D must be aborted by H to prevent its own
>> infinite execution conclusively proves that D specifies non-halting
>> behavior to H. *The only "rebuttals" to this are damned lies*
>
> Linz and many others have proven that there are no halt deciders.
> Olcott's only "rebuttals" to this are damned lies.
>

You can't even found an actual mistake and have the audacity
to call me a liar?

Your last "rebuttal" was anchored in your ignorance about
how deciders are actually defined to work. They must compute
the mapping form their actual inputs.

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

On 3/23/24 12:12 AM, olcott wrote:
> On 3/22/2024 9:17 PM, Richard Damon wrote:
>> On 3/22/24 12:27 AM, olcott wrote:
>>> On 3/21/2024 10:10 PM, Richard Damon wrote:
>>>>
>>>> Right, and that H fails to be a decider.
>>>>
>>>> But if H does abort it simulation, then the fact that the other
>>>> instances
>>>
>>> Can't be the ones to abort because every H has the same machine-code
>>> thus the executed H cannot wait for simulated H(D,D) to abort or no H
>>> would ever abort. Your software engineering skill must be pretty weak.
>>>
>>
>> How is "Every H" the same machine code?
>>
>
> Every H between the directly executed H and all of
> its simulated H are the exact same machine code.

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

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

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

1) One is the instances withing a given program

2) The different versions you might try.

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

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

>
>> I think you are confusing your lies.
>>
>> The problem is that even if the "C function" D is the same machine
>> code, the fact that it calls an external H means the code of H affects
>> its behavior, and that must be taken into account.
>>
>
> *Yes we are getting somewhere now* an actual honest dialogue.

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

>
>> You are just proving you ar just a STUPID LIAR that can't keep your
>> stories straight.
>>
>
> If that was true then I would not have just agreed with you.
>

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

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

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

Right, and since D,D specifies the program D(D) and that Halts, the
mapping is from D,D -> 1 not 0.

THAT is the ACTUAL INPUT.

Not the D based on the OTHER H that doesn't abort and makes D(D) run
forever.

THAT is just a lie, but is what you are answering about.

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

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

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

01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?

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

On 3/23/2024 9:14 AM, Richard Damon wrote:
> On 3/23/24 12:12 AM, olcott wrote:
>> On 3/22/2024 9:17 PM, Richard Damon wrote:
>>> On 3/22/24 12:27 AM, olcott wrote:
>>>> On 3/21/2024 10:10 PM, Richard Damon wrote:
>>>>>
>>>>> Right, and that H fails to be a decider.
>>>>>
>>>>> But if H does abort it simulation, then the fact that the other
>>>>> instances
>>>>
>>>> Can't be the ones to abort because every H has the same machine-code
>>>> thus the executed H cannot wait for simulated H(D,D) to abort or no H
>>>> would ever abort. Your software engineering skill must be pretty weak.
>>>>
>>>
>>> How is "Every H" the same machine code?
>>>
>>
>> Every H between the directly executed H and all of
>> its simulated H are the exact same machine code.
>
> So? They are different execution instances so have their own identity.
>
> If you didn't artificially limit your system to only being a TOY, then
> the copy of the H that D uses could actually be different (but
> equivalent) code.
>

*Mine is exactly isomorphic to this one*
An impossible program C. Strachey
The Computer Journal, Volume 7, Issue 4, January 1965, Page 313,
https://doi.org/10.1093/comjnl/7.4.313
Published: 01 January 1965

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

I was trying to give you one thing to consider at a time
because when I give you more than one thing at a time you
get overwhelmed and confused.

Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.

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

> 1) One is the instances withing a given program
>
> 2) The different versions you might try.
>
> For 1), you need to remember that H is what it is, and needs to justify
> its behavior based on that fact, and NOT what a 2) alternate might do.
>
> SINCE our final H aborts its simulation, THAT IS what determines the
> behavior of D, and for that D, THIS INSTANCE of H doesn't NEED to abort
> its simulation, but does.
>
>>
>>> I think you are confusing your lies.
>>>
>>> The problem is that even if the "C function" D is the same machine
>>> code, the fact that it calls an external H means the code of H
>>> affects its behavior, and that must be taken into account.
>>>
>>
>> *Yes we are getting somewhere now* an actual honest dialogue.
>
> So, you agree that D's behavior is affected by the H defined, and thus

*Yes that is the point that you previously persistently denied*
*Yes that is the point that you previously persistently denied*
*Yes that is the point that you previously persistently denied*

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

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

This is why H(D,D) != H1(D,D)

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

On 2024-03-23 14:02:45 +0000, olcott said:

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

On 2024-03-23 14:09:35 +0000, olcott said:

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

Both mistakes and lies have been found and pointed out. No need
to repeat.

What matters is that you have't retracted your claim that Linz
made a mistake that you can't point out.

--
Mikko

On 2024-03-23 14:05:09 +0000, olcott said:

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