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

"Basis for a computation" is something that you randomly made up and it
doesn't mean anything. Try again.

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

Try and reason it through for yourself.
Is is legitimate to require a TM to compute
something that is only in your own head?

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

On 24/03/24 03:38, olcott wrote:
> On 3/23/2024 9:19 PM, immibis wrote:
>> On 24/03/24 03:13, olcott wrote:
>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>> On 24/03/24 00:23, olcott wrote:
>>>>> On 3/23/2024 5:59 PM, immibis wrote:
>>>>>> On 23/03/24 15:41, olcott wrote:
>>>>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>>>>
>>>>>>> Since you know that D(D) correctly simulated by H cannot
>>>>>>> possibly halt, why lie about this and use the strawman
>>>>>>> deception to refer to an instance of D(D) that does not
>>>>>>> even exist in the above computation?
>>>>>>>
>>>>>> The halting problem is about whether a program halts not whether a
>>>>>> "correct simulation" of that program halts.
>>>>>
>>>>> The halting problem is about computing the mapping from the inputs
>>>>> to an accept or reject state on the basis of the behavior that the
>>>>> input specifies.
>>>>>
>>>>> *The input to H(D,D) specifies non-halting behavior to H*
>>>>> The above are self-evidently true facts and cannot be denied
>>>>> without error.
>>>>>
>>>>
>>>> The halting problem is quite simple:
>>>> Create a program HaltCheck (or Turing machine) so that:
>>>> * the input Prog,Input is another program (or Turing machine) and
>>>> its input
>>>> * HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
>>>> would halt
>>>> * HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
>>>> would never halt
>>>
>>> The basis for such a computation must be something that H can see
>>> and thus not what you and others simply imagine.
>>>
>>
>> "Basis for a computation" is something that you randomly made up and
>> it doesn't mean anything. Try again.
>
> Try and reason it through for yourself.
> Is is legitimate to require a TM to compute
> something that is only in your own head?

"legitimate" for this is something that you randomly made up and it
doesn't mean anything. Try again.

On 3/23/2024 9:53 PM, immibis wrote:
> On 24/03/24 03:38, olcott wrote:
>> On 3/23/2024 9:19 PM, immibis wrote:
>>> On 24/03/24 03:13, olcott wrote:
>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>> On 24/03/24 00:23, olcott wrote:
>>>>>> On 3/23/2024 5:59 PM, immibis wrote:
>>>>>>> On 23/03/24 15:41, olcott wrote:
>>>>>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>>>>>
>>>>>>>> Since you know that D(D) correctly simulated by H cannot
>>>>>>>> possibly halt, why lie about this and use the strawman
>>>>>>>> deception to refer to an instance of D(D) that does not
>>>>>>>> even exist in the above computation?
>>>>>>>>
>>>>>>> The halting problem is about whether a program halts not whether
>>>>>>> a "correct simulation" of that program halts.
>>>>>>
>>>>>> The halting problem is about computing the mapping from the inputs
>>>>>> to an accept or reject state on the basis of the behavior that the
>>>>>> input specifies.
>>>>>>
>>>>>> *The input to H(D,D) specifies non-halting behavior to H*
>>>>>> The above are self-evidently true facts and cannot be denied
>>>>>> without error.
>>>>>>
>>>>>
>>>>> The halting problem is quite simple:
>>>>> Create a program HaltCheck (or Turing machine) so that:
>>>>> * the input Prog,Input is another program (or Turing machine) and
>>>>> its input
>>>>> * HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
>>>>> would halt
>>>>> * HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
>>>>> would never halt
>>>>
>>>> The basis for such a computation must be something that H can see
>>>> and thus not what you and others simply imagine.
>>>>
>>>
>>> "Basis for a computation" is something that you randomly made up and
>>> it doesn't mean anything. Try again.
>>
>> Try and reason it through for yourself.
>> Is is legitimate to require a TM to compute
>> something that is only in your own head?
>
> "legitimate" for this is something that you randomly made up and it
> doesn't mean anything. Try again.

Is is legitimate to require a TM to compute
something that is only in your own head?

--
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 16:16:18 +0000, olcott said:

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

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

And you NEED to take that into account.

The question is STILL about the direct running of that exact same input,
which means directly running the D "paired" to the H that is going to be
"deciding it".

This is a PERFECTLY VALID operation, and doable in your system.

For instance, just have main call D(D) with THAT H still in the program,
or have main call UTM(D,D) with THAT H still in the program at the
location that H always is.

If you can't, then you are just admitting that you are making your
system much weaker than "Turing Complete", and thus meaningless to talk
about "Halting Problems".

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

Nope.

You don't seem to understand what Computations Theory is about.

The question for the Theory is: DOES such a method exist?, not require
it to and implement.

On 3/23/24 11:31 PM, olcott wrote:
> On 3/23/2024 9:53 PM, immibis wrote:
>> On 24/03/24 03:38, olcott wrote:
>>> On 3/23/2024 9:19 PM, immibis wrote:
>>>> On 24/03/24 03:13, olcott wrote:
>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>> On 24/03/24 00:23, olcott wrote:
>>>>>>> On 3/23/2024 5:59 PM, immibis wrote:
>>>>>>>> On 23/03/24 15:41, olcott wrote:
>>>>>>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>>>>>>
>>>>>>>>> Since you know that D(D) correctly simulated by H cannot
>>>>>>>>> possibly halt, why lie about this and use the strawman
>>>>>>>>> deception to refer to an instance of D(D) that does not
>>>>>>>>> even exist in the above computation?
>>>>>>>>>
>>>>>>>> The halting problem is about whether a program halts not whether
>>>>>>>> a "correct simulation" of that program halts.
>>>>>>>
>>>>>>> The halting problem is about computing the mapping from the inputs
>>>>>>> to an accept or reject state on the basis of the behavior that the
>>>>>>> input specifies.
>>>>>>>
>>>>>>> *The input to H(D,D) specifies non-halting behavior to H*
>>>>>>> The above are self-evidently true facts and cannot be denied
>>>>>>> without error.
>>>>>>>
>>>>>>
>>>>>> The halting problem is quite simple:
>>>>>> Create a program HaltCheck (or Turing machine) so that:
>>>>>> * the input Prog,Input is another program (or Turing machine) and
>>>>>> its input
>>>>>> * HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
>>>>>> would halt
>>>>>> * HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
>>>>>> would never halt
>>>>>
>>>>> The basis for such a computation must be something that H can see
>>>>> and thus not what you and others simply imagine.
>>>>>
>>>>
>>>> "Basis for a computation" is something that you randomly made up and
>>>> it doesn't mean anything. Try again.
>>>
>>> Try and reason it through for yourself.
>>> Is is legitimate to require a TM to compute
>>> something that is only in your own head?
>>
>> "legitimate" for this is something that you randomly made up and it
>> doesn't mean anything. Try again.
>
> Is is legitimate to require a TM to compute
> something that is only in your own head?
>

And your asking the question just reveals your utter ignorance of the topic.

On 3/23/24 9:53 PM, olcott wrote:
> On 3/23/2024 7:22 PM, Richard Damon wrote:
>> On 3/23/24 5:08 PM, olcott wrote:
>>> On 3/23/2024 4:02 PM, Richard Damon wrote:
>>>> On 3/23/24 3:25 PM, olcott wrote:
>>>>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>>>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) must either abort or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider if it tells whether the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem, not the Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory of simulating abort deciders so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it solves the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead of merely solving the Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer to an incorrect question
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus must be redefined.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Question.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one entity
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another entity
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this second entity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then "yes"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the correct answer to all entities.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted
>>>>>>>>>>>>>>>>>>>>>>>>>>>> by a liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should
>>>>>>>>>>>>>>>>>>>>>>>>>> give is "yes".
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes. The
>>>>>>>>>>>>>>>>>>>>>>>> new H does not give the correct answer for the
>>>>>>>>>>>>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes. The
>>>>>>>>>>>>>>>>>>>>>>>> new H does not give the correct answer for the
>>>>>>>>>>>>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes. The
>>>>>>>>>>>>>>>>>>>>>>>> new H does not give the correct answer for the
>>>>>>>>>>>>>>>>>>>>>>>> new D.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems
>>>>>>>>>>>>>>>>>>>>>>>> Olcott is again confused, because he uses the
>>>>>>>>>>>>>>>>>>>>>>>> same names for different things.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Trying to refer to a different H than every H is
>>>>>>>>>>>>>>>>>>>>>>> a very lame
>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he
>>>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are
>>>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a halt
>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If an honest dialogue is the goal then points of mutual
>>>>>>>>>>>>>>>>> agreement
>>>>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I admitted that I was wrong about the details of some
>>>>>>>>>>>>>>>>> things:
>>>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is
>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *See if you can rebut this with reasoning instead of
>>>>>>>>>>>>>>> rhetoric*
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>> criteria--Mikes-rebuttal--]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning
>>>>>>>>>>>>>> or rhetoric.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>>>>
>>>>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count as
>>>>>>>>>>>> reasoning"
>>>>>>>>>>>> do count as rhetoric.
>>>>>>>>>>>>
>>>>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning
>>>>>>>>>>> basis.
>>>>>>>>>>> I am correct when I do this.
>>>>>>>>>>
>>>>>>>>>> You usually don't. Moreoften you produce fake "rebuttals" that
>>>>>>>>>> lack
>>>>>>>>>> any correct reasoning basis.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *So far no one has actually shown that*
>>>>>>>>
>>>>>>>> Suffiecent evidence can be found in recent messages in comp.theory.
>>>>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>>>>> that everithing is sufficiently clear to most participants.
>>>>>>>>
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> For the entire set of every implmentation of H where H simulates
>>>>>>> its input no D can possibly reach its own final state at line 06
>>>>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>>>>
>>>>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING*
>>>>>> either.
>>>>>> So, an aborted simulation cannot prove that an abort is required.
>>>>>>
>>>>>
>>>>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>>>>> That is merely yet another instance of the strawman deception.
>>>>> We never have been talking about an arbitrary aborted simulation.
>>>>
>>>> Right, H aborting its simulation doesn't make the input Non-Halting,
>>>> that is based on the DIRECT EXECUTION of that input exactly as it
>>>> was presented to H, that is, calling the H that it was originally
>>>> calling. (the one claimed to give the right answer)
>>>>
>>>>>
>>>>> We have only been talking about a simulation of D by H that cannot
>>>>> possibly reach its own final state at line 06 in an infinite number
>>>>> of steps of correct simulation.
>>>>
>>>> Then I guess you are admitting that you only H just fails to be a
>>>> decider, since it actually does just simulate its input for an
>>>> infinite number of steps.
>>>>
>>>> I guess you are done and admit defeat.
>>>>
>>>> Now, I KNOW you are just lying, because you are ACTUALLY going to
>>>> say that now that we have established this is what D does, H can be
>>>> changed to abort, but then we have to throw out that conclusion, as
>>>> D changes when we change H.
>>>>
>>>>
>>>> So, if H DOES abort its simulation then this aborting does NOT, by
>>>> itself make D non-halting, but we need to look at what D actually does.
>>>>
>>>> If D aborts its simulation and call the input non-halting, then D
>>>> will halt, and thus H was just INCORRECT to have aborted its
>>>> simulation, as this new behavior of D was established when we
>>>> changed H, so NOW it is not correct to abort its simulation
>>>>
>>>>>
>>>>> Everyone with sufficient programming skill can see that this is a
>>>>> verified fact:
>>>>>
>>>>> *D correctly simulated by H cannot possibly reach its own final state*
>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>> Some of these people might lie about it.
>>>>>
>>>>
>>>> Right, so if H does correctly simulate D, then it doesn't abort and
>>>> fails to be a decider.
>>>>
>>>
>>> *Like I said some people might lie about it*
>>> H does correctly simulate D until it can see that every D simulated
>>> by any H cannot possibly halt. Then H has its correct basis to abort
>>> its simulation of D and reject D as non-halting.
>>>
>>
>> But that isn't the question, so it gets the wrong answer.
>>
> (1) It is the abort/no abort question.
>
> (2) H(D,D) does correctly compute the mapping from its
>     input to its own reject state on the basis of (1)
>
> H(D,D) does see that its input D(D) never halts and that
> is the only thing that H is accountable for determining.
>
> int sum(int a, int y) { return x + y; }
> sum(2,3) is not accountable for reporting on the sum of 5 + 6.

On 2024-03-23 23:23:32 +0000, olcott said:

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

The input D,D specifies exaclty one behaviour that does not depend
on whom that behaviour is told. Any misinterpretation by H does not
change the specified behaviour.

--
Mikko

On 2024-03-24 02:38:02 +0000, olcott said:

> On 3/23/2024 9:19 PM, immibis wrote:
>> On 24/03/24 03:13, olcott wrote:
>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>> On 24/03/24 00:23, olcott wrote:
>>>>> On 3/23/2024 5:59 PM, immibis wrote:
>>>>>> On 23/03/24 15:41, olcott wrote:
>>>>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>>>>
>>>>>>> Since you know that D(D) correctly simulated by H cannot
>>>>>>> possibly halt, why lie about this and use the strawman
>>>>>>> deception to refer to an instance of D(D) that does not
>>>>>>> even exist in the above computation?
>>>>>>>
>>>>>> The halting problem is about whether a program halts not whether a
>>>>>> "correct simulation" of that program halts.
>>>>>
>>>>> The halting problem is about computing the mapping from the inputs
>>>>> to an accept or reject state on the basis of the behavior that the
>>>>> input specifies.
>>>>>
>>>>> *The input to H(D,D) specifies non-halting behavior to H*
>>>>> The above are self-evidently true facts and cannot be denied
>>>>> without error.
>>>>>
>>>>
>>>> The halting problem is quite simple:
>>>> Create a program HaltCheck (or Turing machine) so that:
>>>> * the input Prog,Input is another program (or Turing machine) and its input
>>>> * HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input) would halt
>>>> * HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input) would
>>>> never halt
>>>
>>> The basis for such a computation must be something that H can see
>>> and thus not what you and others simply imagine.
>>>
>>
>> "Basis for a computation" is something that you randomly made up and it
>> doesn't mean anything. Try again.
>
> Try and reason it through for yourself.
> Is is legitimate to require a TM to compute
> something that is only in your own head?

Yes.

--
Mikko

On 2024-03-23 16:28:22 +0000, olcott said:

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

Have you found any mistake in Linz' book?

--
Mikko

On 2024-03-23 16:30:35 +0000, olcott said:

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

On 2024-03-23 16:42:57 +0000, olcott said:

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

On 2024-03-23 16:45:54 +0000, olcott said:

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

On 24/03/24 04:31, olcott wrote:
> On 3/23/2024 9:53 PM, immibis wrote:
>> On 24/03/24 03:38, olcott wrote:
>>> On 3/23/2024 9:19 PM, immibis wrote:
>>>> On 24/03/24 03:13, olcott wrote:
>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>> On 24/03/24 00:23, olcott wrote:
>>>>>>> On 3/23/2024 5:59 PM, immibis wrote:
>>>>>>>> On 23/03/24 15:41, olcott wrote:
>>>>>>>>> On 3/23/2024 9:18 AM, Richard Damon wrote:
>>>>>>>>>> Right, and since D,D specifies the program D(D) and that Halts,
>>>>>>>>>
>>>>>>>>> Since you know that D(D) correctly simulated by H cannot
>>>>>>>>> possibly halt, why lie about this and use the strawman
>>>>>>>>> deception to refer to an instance of D(D) that does not
>>>>>>>>> even exist in the above computation?
>>>>>>>>>
>>>>>>>> The halting problem is about whether a program halts not whether
>>>>>>>> a "correct simulation" of that program halts.
>>>>>>>
>>>>>>> The halting problem is about computing the mapping from the inputs
>>>>>>> to an accept or reject state on the basis of the behavior that the
>>>>>>> input specifies.
>>>>>>>
>>>>>>> *The input to H(D,D) specifies non-halting behavior to H*
>>>>>>> The above are self-evidently true facts and cannot be denied
>>>>>>> without error.
>>>>>>>
>>>>>>
>>>>>> The halting problem is quite simple:
>>>>>> Create a program HaltCheck (or Turing machine) so that:
>>>>>> * the input Prog,Input is another program (or Turing machine) and
>>>>>> its input
>>>>>> * HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
>>>>>> would halt
>>>>>> * HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
>>>>>> would never halt
>>>>>
>>>>> The basis for such a computation must be something that H can see
>>>>> and thus not what you and others simply imagine.
>>>>>
>>>>
>>>> "Basis for a computation" is something that you randomly made up and
>>>> it doesn't mean anything. Try again.
>>>
>>> Try and reason it through for yourself.
>>> Is is legitimate to require a TM to compute
>>> something that is only in your own head?
>>
>> "legitimate" for this is something that you randomly made up and it
>> doesn't mean anything. Try again.
>
> Is is legitimate to require a TM to compute
> something that is only in your own head?
>
"legitimate" is a meaningless word you made up when it is applied to
Turing Machine questions.

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

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

On 2024-03-25 17:59:45 +0000, olcott said:

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

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

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

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

Yes both Ben and I agree that Ĥ should not have two start states.

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

If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.

--
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/24/2024 7:03 AM, Richard Damon wrote:
> On 3/23/24 9:53 PM, olcott wrote:
>> On 3/23/2024 7:22 PM, Richard Damon wrote:
>>> On 3/23/24 5:08 PM, olcott wrote:
>>>> On 3/23/2024 4:02 PM, Richard Damon wrote:
>>>>> On 3/23/24 3:25 PM, olcott wrote:
>>>>>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>>>>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>>>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) must either abort or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider if it tells whether the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is a correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem, not the Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of simulating abort deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory of simulating abort deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so that it solves the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead of merely solving the Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer to an incorrect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question thus must be redefined.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Question.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one entity
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another entity
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this second entity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "yes" is the correct answer to all entities.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What is true is true even when contradicted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by a liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should
>>>>>>>>>>>>>>>>>>>>>>>>>>> give is "yes".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer*
>>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes.
>>>>>>>>>>>>>>>>>>>>>>>>> The new H does not give the correct answer for
>>>>>>>>>>>>>>>>>>>>>>>>> the new D.
>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer*
>>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes.
>>>>>>>>>>>>>>>>>>>>>>>>> The new H does not give the correct answer for
>>>>>>>>>>>>>>>>>>>>>>>>> the new D.
>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer*
>>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes.
>>>>>>>>>>>>>>>>>>>>>>>>> The new H does not give the correct answer for
>>>>>>>>>>>>>>>>>>>>>>>>> the new D.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems
>>>>>>>>>>>>>>>>>>>>>>>>> Olcott is again confused, because he uses the
>>>>>>>>>>>>>>>>>>>>>>>>> same names for different things.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Trying to refer to a different H than every H is
>>>>>>>>>>>>>>>>>>>>>>>> a very lame
>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he
>>>>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are
>>>>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation is
>>>>>>>>>>>>>>>>>>>>>> exactly equal in
>>>>>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a
>>>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If an honest dialogue is the goal then points of
>>>>>>>>>>>>>>>>>> mutual agreement
>>>>>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I admitted that I was wrong about the details of some
>>>>>>>>>>>>>>>>>> things:
>>>>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is
>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *See if you can rebut this with reasoning instead of
>>>>>>>>>>>>>>>> rhetoric*
>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>> criteria--Mikes-rebuttal--]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I just note that you have rebutted nothing wirh reasoning
>>>>>>>>>>>>>>> or rhetoric.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count
>>>>>>>>>>>>> as reasoning"
>>>>>>>>>>>>> do count as rhetoric.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning
>>>>>>>>>>>> basis.
>>>>>>>>>>>> I am correct when I do this.
>>>>>>>>>>>
>>>>>>>>>>> You usually don't. Moreoften you produce fake "rebuttals"
>>>>>>>>>>> that lack
>>>>>>>>>>> any correct reasoning basis.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *So far no one has actually shown that*
>>>>>>>>>
>>>>>>>>> Suffiecent evidence can be found in recent messages in
>>>>>>>>> comp.theory.
>>>>>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>>>>>> that everithing is sufficiently clear to most participants.
>>>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> For the entire set of every implmentation of H where H simulates
>>>>>>>> its input no D can possibly reach its own final state at line 06
>>>>>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>>>>>
>>>>>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING*
>>>>>>> either.
>>>>>>> So, an aborted simulation cannot prove that an abort is required.
>>>>>>>
>>>>>>
>>>>>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>>>>>> That is merely yet another instance of the strawman deception.
>>>>>> We never have been talking about an arbitrary aborted simulation.
>>>>>
>>>>> Right, H aborting its simulation doesn't make the input
>>>>> Non-Halting, that is based on the DIRECT EXECUTION of that input
>>>>> exactly as it was presented to H, that is, calling the H that it
>>>>> was originally calling. (the one claimed to give the right answer)
>>>>>
>>>>>>
>>>>>> We have only been talking about a simulation of D by H that cannot
>>>>>> possibly reach its own final state at line 06 in an infinite number
>>>>>> of steps of correct simulation.
>>>>>
>>>>> Then I guess you are admitting that you only H just fails to be a
>>>>> decider, since it actually does just simulate its input for an
>>>>> infinite number of steps.
>>>>>
>>>>> I guess you are done and admit defeat.
>>>>>
>>>>> Now, I KNOW you are just lying, because you are ACTUALLY going to
>>>>> say that now that we have established this is what D does, H can be
>>>>> changed to abort, but then we have to throw out that conclusion, as
>>>>> D changes when we change H.
>>>>>
>>>>>
>>>>> So, if H DOES abort its simulation then this aborting does NOT, by
>>>>> itself make D non-halting, but we need to look at what D actually
>>>>> does.
>>>>>
>>>>> If D aborts its simulation and call the input non-halting, then D
>>>>> will halt, and thus H was just INCORRECT to have aborted its
>>>>> simulation, as this new behavior of D was established when we
>>>>> changed H, so NOW it is not correct to abort its simulation
>>>>>
>>>>>>
>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>> verified fact:
>>>>>>
>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>> state*
>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>> Some of these people might lie about it.
>>>>>>
>>>>>
>>>>> Right, so if H does correctly simulate D, then it doesn't abort and
>>>>> fails to be a decider.
>>>>>
>>>>
>>>> *Like I said some people might lie about it*
>>>> H does correctly simulate D until it can see that every D simulated
>>>> by any H cannot possibly halt. Then H has its correct basis to abort
>>>> its simulation of D and reject D as non-halting.
>>>>
>>>
>>> But that isn't the question, so it gets the wrong answer.
>>>
>> (1) It is the abort/no abort question.
>>
>> (2) H(D,D) does correctly compute the mapping from its
>>      input to its own reject state on the basis of (1)
>>
>> H(D,D) does see that its input D(D) never halts and that
>> is the only thing that H is accountable for determining.
>>
>> int sum(int a, int y) { return x + y; }
>> sum(2,3) is not accountable for reporting on the sum of 5 + 6.
>
> Right, because that isn't its input
>
>>
>> H(D,D) is not accountable for reporting on int main() { D(D); }
>> That D(D) relies on H(D,D) having already aborted its simulation.
>> H(D,D) cannot rely on that.
>
> But it IS accountable, you just don't understand the rules.
>
> H(D,D) is DEFINED to be accountable for the behaivor of D(D) if H is a
> Halt Decider (or a Need to abort decider)
>
int sum(int x, int y){ return x + y; }
sum(3,4) is not allowed to report on the sum of 5 + 6
even if you really really believe that it should.

On 3/25/24 6:55 PM, olcott wrote:
> On 3/24/2024 7:03 AM, Richard Damon wrote:
>> On 3/23/24 9:53 PM, olcott wrote:
>>> On 3/23/2024 7:22 PM, Richard Damon wrote:
>>>> On 3/23/24 5:08 PM, olcott wrote:
>>>>> On 3/23/2024 4:02 PM, Richard Damon wrote:
>>>>>> On 3/23/24 3:25 PM, olcott wrote:
>>>>>>> On 3/23/2024 1:47 PM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 17:42 schreef olcott:
>>>>>>>>> On 3/23/2024 11:12 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-23 14:20:17 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/23/2024 6:11 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-22 18:45:01 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/22/2024 1:32 PM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-22 15:43:49 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/22/2024 2:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-21 16:39:52 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/21/2024 11:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-21 15:28:13 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/21/2024 10:14 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-21 14:17:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 3/21/2024 4:47 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 19:30:03 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 3:24 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) must either abort or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. H is a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider if it tells whether the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is a correct abort decider then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> else that requires the prerequisite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman deception. It is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem, not the Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can learn calculus without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of algebra. You can't learn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of simulating abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When are you going to extend this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory of simulating abort deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so that it solves the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem instead of merely solving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Olcott abort problem?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer to an incorrect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question thus must be redefined.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But (2) is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is nothing "Incorrect" about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Question.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one entity
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another entity
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this second entity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Ĥ is your x86utm function D, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "yes" is the correct answer to all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> entities.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *counter factual*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What is true is true even when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contradicted by a liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore the correct answer H(D,D) should
>>>>>>>>>>>>>>>>>>>>>>>>>>>> give is "yes".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>> answer*
>>>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes.
>>>>>>>>>>>>>>>>>>>>>>>>>> The new H does not give the correct answer for
>>>>>>>>>>>>>>>>>>>>>>>>>> the new D.
>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>> answer*
>>>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes.
>>>>>>>>>>>>>>>>>>>>>>>>>> The new H does not give the correct answer for
>>>>>>>>>>>>>>>>>>>>>>>>>> the new D.
>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>> answer*
>>>>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build
>>>>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the
>>>>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes.
>>>>>>>>>>>>>>>>>>>>>>>>>> The new H does not give the correct answer for
>>>>>>>>>>>>>>>>>>>>>>>>>> the new D.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Both questions have a correct answer, but the
>>>>>>>>>>>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems
>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott is again confused, because he uses the
>>>>>>>>>>>>>>>>>>>>>>>>>> same names for different things.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Trying to refer to a different H than every H
>>>>>>>>>>>>>>>>>>>>>>>>> is a very lame
>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Very weak response. I did not say different from
>>>>>>>>>>>>>>>>>>>>>>>> every H.
>>>>>>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he
>>>>>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are
>>>>>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every H(D,D) that does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>> is exactly equal in
>>>>>>>>>>>>>>>>>>>>>>> that none of them ever stop running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> True but not very relevant as none of them is a
>>>>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We must start with H(D,D) is a correct abort decider
>>>>>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Perhaps you must. Others needn't.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Until this is understood one lacks the sufficient
>>>>>>>>>>>>>>>>>>> prerequisites to
>>>>>>>>>>>>>>>>>>> comprehend any further elaborations.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If an honest dialogue is the goal then points of
>>>>>>>>>>>>>>>>>>> mutual agreement
>>>>>>>>>>>>>>>>>>> must be reached.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I admitted that I was wrong about the details of some
>>>>>>>>>>>>>>>>>>> things:
>>>>>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H
>>>>>>>>>>>>>>>>>>> is this
>>>>>>>>>>>>>>>>>>> exact same H. I was wrong when I said that it could.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *This provides evidence that I want an honest dialogue*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In sufficient as you have provided much more contrary
>>>>>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you
>>>>>>>>>>>>>>>>>> participate.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *See if you can rebut this with reasoning instead of
>>>>>>>>>>>>>>>>> rhetoric*
>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>> criteria--Mikes-rebuttal--]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I just note that you have rebutted nothing wirh
>>>>>>>>>>>>>>>> reasoning or rhetoric.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Dogmatic statements do not count as reasoning.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Dgmatic statements likn "Dogmatic statements do not count
>>>>>>>>>>>>>> as reasoning"
>>>>>>>>>>>>>> do count as rhetoric.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Observation of a fact is does not count as dogmatic.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I call out fake "rebuttals" that lack any correct reasoning
>>>>>>>>>>>>> basis.
>>>>>>>>>>>>> I am correct when I do this.
>>>>>>>>>>>>
>>>>>>>>>>>> You usually don't. Moreoften you produce fake "rebuttals"
>>>>>>>>>>>> that lack
>>>>>>>>>>>> any correct reasoning basis.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *So far no one has actually shown that*
>>>>>>>>>>
>>>>>>>>>> Suffiecent evidence can be found in recent messages in
>>>>>>>>>> comp.theory.
>>>>>>>>>> ANyone is free to ask if something remains unclear. But it seems
>>>>>>>>>> that everithing is sufficiently clear to most participants.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> For the entire set of every implmentation of H where H simulates
>>>>>>>>> its input no D can possibly reach its own final state at line 06
>>>>>>>>> and halt. An aborted simulation *DOES NOT COUNT AS HALTING*
>>>>>>>>
>>>>>>>> Similarly, an aborted simulation *DOES NOT COUNT AS NON-HALTING*
>>>>>>>> either.
>>>>>>>> So, an aborted simulation cannot prove that an abort is required.
>>>>>>>>
>>>>>>>
>>>>>>> An arbitrary aborted simulation *DOES NOT COUNT AS NON-HALTING*.
>>>>>>> That is merely yet another instance of the strawman deception.
>>>>>>> We never have been talking about an arbitrary aborted simulation.
>>>>>>
>>>>>> Right, H aborting its simulation doesn't make the input
>>>>>> Non-Halting, that is based on the DIRECT EXECUTION of that input
>>>>>> exactly as it was presented to H, that is, calling the H that it
>>>>>> was originally calling. (the one claimed to give the right answer)
>>>>>>
>>>>>>>
>>>>>>> We have only been talking about a simulation of D by H that cannot
>>>>>>> possibly reach its own final state at line 06 in an infinite number
>>>>>>> of steps of correct simulation.
>>>>>>
>>>>>> Then I guess you are admitting that you only H just fails to be a
>>>>>> decider, since it actually does just simulate its input for an
>>>>>> infinite number of steps.
>>>>>>
>>>>>> I guess you are done and admit defeat.
>>>>>>
>>>>>> Now, I KNOW you are just lying, because you are ACTUALLY going to
>>>>>> say that now that we have established this is what D does, H can
>>>>>> be changed to abort, but then we have to throw out that
>>>>>> conclusion, as D changes when we change H.
>>>>>>
>>>>>>
>>>>>> So, if H DOES abort its simulation then this aborting does NOT, by
>>>>>> itself make D non-halting, but we need to look at what D actually
>>>>>> does.
>>>>>>
>>>>>> If D aborts its simulation and call the input non-halting, then D
>>>>>> will halt, and thus H was just INCORRECT to have aborted its
>>>>>> simulation, as this new behavior of D was established when we
>>>>>> changed H, so NOW it is not correct to abort its simulation
>>>>>>
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>> verified fact:
>>>>>>>
>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>> state*
>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>> Some of these people might lie about it.
>>>>>>>
>>>>>>
>>>>>> Right, so if H does correctly simulate D, then it doesn't abort
>>>>>> and fails to be a decider.
>>>>>>
>>>>>
>>>>> *Like I said some people might lie about it*
>>>>> H does correctly simulate D until it can see that every D simulated
>>>>> by any H cannot possibly halt. Then H has its correct basis to abort
>>>>> its simulation of D and reject D as non-halting.
>>>>>
>>>>
>>>> But that isn't the question, so it gets the wrong answer.
>>>>
>>> (1) It is the abort/no abort question.
>>>
>>> (2) H(D,D) does correctly compute the mapping from its
>>>      input to its own reject state on the basis of (1)
>>>
>>> H(D,D) does see that its input D(D) never halts and that
>>> is the only thing that H is accountable for determining.
>>>
>>> int sum(int a, int y) { return x + y; }
>>> sum(2,3) is not accountable for reporting on the sum of 5 + 6.
>>
>> Right, because that isn't its input
>>
>>>
>>> H(D,D) is not accountable for reporting on int main() { D(D); }
>>> That D(D) relies on H(D,D) having already aborted its simulation.
>>> H(D,D) cannot rely on that.
>>
>> But it IS accountable, you just don't understand the rules.
>>
>> H(D,D) is DEFINED to be accountable for the behaivor of D(D) if H is a
>> Halt Decider (or a Need to abort decider)
>>
> int sum(int x, int y){ return x + y; }
> sum(3,4) is not allowed to report on the sum of 5 + 6
> even if you really really believe that it should.
>