On 3/28/2024 7:51 AM, Mikko wrote:
> On 2024-03-26 14:31:38 +0000, olcott said:
>
>> On 3/26/2024 3:33 AM, Mikko wrote:
>>> On 2024-03-25 22:43:42 +0000, olcott said:
>>>
>>>
>>> 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.
>>>
>>>
>>> Perhaps Linz' presentation is not clear enough for you but Linz Ĥ
>>>
>>> has only one start state. When Linz says that an action is prepended
>>>
>>> that means that the start state of H is not the sart state of Ĥ.
>>>
>>>
>>> --
>>>
>>> Mikko
>>>
>>
>> Whatever you did to the formatting it screwed it up.
>
> Something strange happaened. My message (date 3/26/2024 3:33 AM)
> looks good on my reader except that it there are some empty lines
> added. Your message (date Tue, 26 Mar 2024 09:31:38 -0500) has
> all quotes at the same level. My message (date 3/24/2024 12:04 PM)
> does not fix that (I din't notice the problem).
>
>> *Linz Ĥ has q0 at its first state and q0 at its second state*
>
> To me it is clear that the former is the q0 state of Ĥ and the
> latter refers to the state q0 of H. The name of the state q0
> of H is in Ĥ does not matter so Linz does not specify it.
>

q0 Wm ⊢* Ĥq0 Wm Wm ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ∞
Does not say that the middle state is H, mine does so mine is better.
Ĥ.q0 Wm ⊢* Ĥ.Hq0 Wm Wm ⊢* Ĥ.Hqy ∞

>> *My Ĥ has one q0 state and the next q0 is an H state*
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> That is one possible way to name it.
>

I think it is the clearest way.

--
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/28/2024 7:30 AM, Mikko wrote:
> On 2024-03-26 14:24:37 +0000, olcott said:
>
>> On 3/26/2024 3:27 AM, Mikko wrote:
>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>
>>>> 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.
>>>
>>> Right, except that instead of "would" it is better to say "does".
>>
>> H1(D,D) does not need to abort only because H(D,D) does need to abort.
>
> Much bettter.
>

Richard tries to get away with this:

*Every H(D,D) that needs to abort its input never needed to abort*
*its input because some other H somewhere else that did not abort*
*its input already aborted its input that it never aborted*

--
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-28 14:23:57 +0000, olcott said:

> On 3/28/2024 7:54 AM, Mikko wrote:
>> On 2024-03-26 14:37:38 +0000, olcott said:
>>
>
> <snip>
>
>> I have not seen anything that even pretends to be a definition of
>> an abort decider.
>>
>>> *Been providing this definition (with one word changed) for over a year*
>>> (a) If simulating abort decider H correctly simulates its input D until
>>> H correctly determines that its simulated D would never stop running
>>> unless aborted then...
>>
>> That does not pretend to definition of anything. It uses the term
>> "simulationg abort decider" as if that (or at least "abort decider")
>> were defined before that.
>>
>
> A simulating abort decider simulates its input until this input matches
> one of three non-halting behavior patterns:
> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
> or the input halts.

Is that a definition or a dexcription?

--
Mikko

On 3/28/2024 6:38 AM, Richard Damon wrote:
> On 3/27/24 11:50 PM, olcott wrote:
>> On 3/27/2024 10:19 PM, Richard Damon wrote:
>>> On 3/27/24 10:59 PM, olcott wrote:
>>>> On 3/27/2024 9:50 PM, Richard Damon wrote:
>>>>> On 3/27/24 10:26 PM, olcott wrote:
>>>>>> On 3/27/2024 8:45 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 9:06 PM, olcott wrote:
>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>> On 3/26/24 11:19 PM, olcott wrote:
>>>>>>>>>> On 3/26/2024 9:17 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/26/24 10:24 AM, olcott wrote:
>>>>>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, except that instead of "would" it is better to say
>>>>>>>>>>>>> "does".
>>>>>>>>>>>>
>>>>>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need
>>>>>>>>>>>> to abort.
>>>>>>>>>>>
>>>>>>>>>>> No, they are simulating the same thing, so they have the same
>>>>>>>>>>> need to abort or not. They are jus making a different
>>>>>>>>>>> decision about if they wlll.
>>>>>>>>>>
>>>>>>>>>> You already admitted many times that if no H every aborts its
>>>>>>>>>> simulation that D(D) never halts. How are you not lying now?
>>>>>>>>>
>>>>>>>>> Right, No H can simulate the input that is based on it to the
>>>>>>>>> point that it halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>>
>>>>>>>> Not quite:
>>>>>>>> Because D calls H in recursive simulation every correct simulation
>>>>>>>> of 1 to ∞ steps of D never reach their final state at line 07
>>>>>>>> and halt.
>>>>>>>
>>>>>>> And each number of steps was a DIFFENT "program" D, when you
>>>>>>> include the "hidden" input of the H that it calls.
>>>>>>>
>>>>>>
>>>>>> *Yes right these two identical finite strings*
>>>>>> *are different because they are identical*
>>>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>>>
>>>>> No, they are different effective programs because they reference
>>>>> different version of H.
>>>>>
>>>>> You admit that will
>>>>>
>>>>>>
>>>>>> Every H(D,D) that simulates its input <is> equivalent
>>>>>> except for whether it aborts its simulation of not.
>>>>>
>>>>> Which means they are different, and you are using DEVIL TALK.
>>>>>
>>>>>>
>>>>>> Thus for all practical purposes there are only two.
>>>>>> (a) Every H(D,D) that simulates its input and aborts.
>>>>>> (b) Every H(D,D) that simulates its input and does not abort.
>>>>>> Every H must make sure it is a (b) and not an (a).
>>>>>
>>>>> Right, but every D built from an H that is a (B) will also Halt,
>>>>> and thus its simulation doesn't need to be aborted.
>>>>>
>>>>
>>>> In other words every D built from an H aborts never needed to be
>>>> build from an H that aborts.
>>>
>>> No, its simulation never needed to be aborted.
>>>
>>
>> Your every that H(D,D) is not a correct abort decider takes this form:
>> *Every H(D,D) that needs to abort its input never needed to abort*
>> *its input because some other H somewhere else that did not abort*
>> *its input already aborted its input that it never aborted*
>>
>
> No, you are changing the words, because you naturally lie.
>
> This H(D,D), that aborts, doesn't need to abort ITS simulation of D(D)
> (but does), as the DIFFERENT INSTANCE of H that D calls, will abort ITS
> SIMULATION of another copy of D,

And that one does not need to abort either because it can wait on the
next one that waits on the next one...

On 3/28/2024 9:57 AM, Mikko wrote:
> On 2024-03-28 14:23:57 +0000, olcott said:
>
>> On 3/28/2024 7:54 AM, Mikko wrote:
>>> On 2024-03-26 14:37:38 +0000, olcott said:
>>>
>>
>> <snip>
>>
>>> I have not seen anything that even pretends to be a definition of
>>> an abort decider.
>>>
>>>> *Been providing this definition (with one word changed) for over a
>>>> year*
>>>> (a) If simulating abort decider H correctly simulates its input D
>>>> until H correctly determines that its simulated D would never stop
>>>> running unless aborted then...
>>>
>>> That does not pretend to definition of anything. It uses the term
>>> "simulationg abort decider" as if that (or at least "abort decider")
>>> were defined before that.
>>>
>>
>> A simulating abort decider simulates its input until this input
>> matches one of three non-halting behavior patterns:
>> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
>> or the input halts.
>
> Is that a definition or a dexcription?
>

*That is the architectural overview, the definitions are here*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

--
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/28/24 11:34 AM, olcott wrote:
> On 3/28/2024 6:38 AM, Richard Damon wrote:
>> On 3/27/24 11:50 PM, olcott wrote:
>>> On 3/27/2024 10:19 PM, Richard Damon wrote:
>>>> On 3/27/24 10:59 PM, olcott wrote:
>>>>> On 3/27/2024 9:50 PM, Richard Damon wrote:
>>>>>> On 3/27/24 10:26 PM, olcott wrote:
>>>>>>> On 3/27/2024 8:45 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 9:06 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>>>>>>> On 3/26/24 11:19 PM, olcott wrote:
>>>>>>>>>>> On 3/26/2024 9:17 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/26/24 10:24 AM, olcott wrote:
>>>>>>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, except that instead of "would" it is better to say
>>>>>>>>>>>>>> "does".
>>>>>>>>>>>>>
>>>>>>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does
>>>>>>>>>>>>> need to abort.
>>>>>>>>>>>>
>>>>>>>>>>>> No, they are simulating the same thing, so they have the
>>>>>>>>>>>> same need to abort or not. They are jus making a different
>>>>>>>>>>>> decision about if they wlll.
>>>>>>>>>>>
>>>>>>>>>>> You already admitted many times that if no H every aborts its
>>>>>>>>>>> simulation that D(D) never halts. How are you not lying now?
>>>>>>>>>>
>>>>>>>>>> Right, No H can simulate the input that is based on it to the
>>>>>>>>>> point that it halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Not quite:
>>>>>>>>> Because D calls H in recursive simulation every correct simulation
>>>>>>>>> of 1 to ∞ steps of D never reach their final state at line 07
>>>>>>>>> and halt.
>>>>>>>>
>>>>>>>> And each number of steps was a DIFFENT "program" D, when you
>>>>>>>> include the "hidden" input of the H that it calls.
>>>>>>>>
>>>>>>>
>>>>>>> *Yes right these two identical finite strings*
>>>>>>> *are different because they are identical*
>>>>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>>>>> 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
>>>>>>
>>>>>> No, they are different effective programs because they reference
>>>>>> different version of H.
>>>>>>
>>>>>> You admit that will
>>>>>>
>>>>>>>
>>>>>>> Every H(D,D) that simulates its input <is> equivalent
>>>>>>> except for whether it aborts its simulation of not.
>>>>>>
>>>>>> Which means they are different, and you are using DEVIL TALK.
>>>>>>
>>>>>>>
>>>>>>> Thus for all practical purposes there are only two.
>>>>>>> (a) Every H(D,D) that simulates its input and aborts.
>>>>>>> (b) Every H(D,D) that simulates its input and does not abort.
>>>>>>> Every H must make sure it is a (b) and not an (a).
>>>>>>
>>>>>> Right, but every D built from an H that is a (B) will also Halt,
>>>>>> and thus its simulation doesn't need to be aborted.
>>>>>>
>>>>>
>>>>> In other words every D built from an H aborts never needed to be
>>>>> build from an H that aborts.
>>>>
>>>> No, its simulation never needed to be aborted.
>>>>
>>>
>>> Your every that H(D,D) is not a correct abort decider takes this form:
>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>> *its input because some other H somewhere else that did not abort*
>>> *its input already aborted its input that it never aborted*
>>>
>>
>> No, you are changing the words, because you naturally lie.
>>
>> This H(D,D), that aborts, doesn't need to abort ITS simulation of D(D)
>> (but does), as the DIFFERENT INSTANCE of H that D calls, will abort
>> ITS SIMULATION of another copy of D,
>
> And that one does not need to abort either because it can wait on the
> next one that waits on the next one...

On 3/28/24 10:32 AM, olcott wrote:
> On 3/28/2024 7:30 AM, Mikko wrote:
>> On 2024-03-26 14:24:37 +0000, olcott said:
>>
>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>
>>>>> 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.
>>>>
>>>> Right, except that instead of "would" it is better to say "does".
>>>
>>> H1(D,D) does not need to abort only because H(D,D) does need to abort.
>>
>> Much bettter.
>>
>
> Richard tries to get away with this:
>
> *Every H(D,D) that needs to abort its input never needed to abort*
> *its input because some other H somewhere else that did not abort*
> *its input already aborted its input that it never aborted*
>
>

Nope, you keep on lying by changing the words and thus the meaning.

The H that DOES abort, turns out to not NEED to abort (but still does),
because the version of it called by D WILL abort, and return 0 and thus
D(D) Halts, so this H could have reached a conclusion if somehow this
version of it could not abort (but leave all the other version as they
were).

On 3/28/24 10:23 AM, olcott wrote:
> On 3/28/2024 7:54 AM, Mikko wrote:
>> On 2024-03-26 14:37:38 +0000, olcott said:
>>
>
> <snip>
>
>> I have not seen anything that even pretends to be a definition of
>> an abort decider.
>>
>>> *Been providing this definition (with one word changed) for over a year*
>>> (a) If simulating abort decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never stop
>>> running unless aborted then...
>>
>> That does not pretend to definition of anything. It uses the term
>> "simulationg abort decider" as if that (or at least "abort decider")
>> were defined before that.
>>
>
> A simulating abort decider simulates its input until this input matches
> one of three non-halting behavior patterns:
> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
> or the input halts.

Except that your "Recursive simulation" is not a non-halting pattern.

So, your logic is unsound.

>
> 01 void B(ptr x) // ptr is pointer to void function
> 02 {
> 03   A(x, x);
> 04   return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09   A(B,B);
> 10 }
>
> *Execution Trace*
> Line 09: main() invokes A(B,B);
>
> *keeps repeating* (unless aborted)
But it does, so this is just a false predicate.
> Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)

>
> *Simulation invariant*
> B correctly simulated by A cannot possibly reach past its own line 03.

Right, but if A doesn't correctly simulate its input, this is a
meaningless statement.

>
> As soon as line 03 would be executed A sees that B would call
> itself with its same input, then A aborts B.
>

And gets the wrong answer.

PERIOD.

On 3/28/2024 7:06 PM, Richard Damon wrote:
> On 3/28/24 10:32 AM, olcott wrote:
>> On 3/28/2024 7:30 AM, Mikko wrote:
>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>
>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>
>>>>>> 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.
>>>>>
>>>>> Right, except that instead of "would" it is better to say "does".
>>>>
>>>> H1(D,D) does not need to abort only because H(D,D) does need to abort.
>>>
>>> Much bettter.
>>>
>>
>> Richard tries to get away with this:
>>
>> *Every H(D,D) that needs to abort its input never needed to abort*
>> *its input because some other H somewhere else that did not abort*
>> *its input already aborted its input that it never aborted*
>>
>>
>
> Nope, you keep on lying by changing the words and thus the meaning.
>
> The H that DOES abort, turns out to not NEED to abort (but still does),
> because the version of it called by D WILL abort, and return 0 and thus
> D(D) Halts, so this H could have reached a conclusion if somehow this
> version of it could not abort (but leave all the other version as they
> were).
>

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.

--
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/28/24 10:03 PM, olcott wrote:
> On 3/28/2024 7:06 PM, Richard Damon wrote:
>> On 3/28/24 10:32 AM, olcott wrote:
>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>
>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>
>>>>>>> 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.
>>>>>>
>>>>>> Right, except that instead of "would" it is better to say "does".
>>>>>
>>>>> H1(D,D) does not need to abort only because H(D,D) does need to abort.
>>>>
>>>> Much bettter.
>>>>
>>>
>>> Richard tries to get away with this:
>>>
>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>> *its input because some other H somewhere else that did not abort*
>>> *its input already aborted its input that it never aborted*
>>>
>>>
>>
>> Nope, you keep on lying by changing the words and thus the meaning.
>>
>> The H that DOES abort, turns out to not NEED to abort (but still
>> does), because the version of it called by D WILL abort, and return 0
>> and thus D(D) Halts, so this H could have reached a conclusion if
>> somehow this version of it could not abort (but leave all the other
>> version as they were).
>>
>
> Because every H in the entire recursive chain has the exact same machine
> code unless the outermost directly executed one aborts its simulation
> then none of them do.

So?

If the outer one is coded to abort, then they ALL abort, and it can be
shown that NONE of them actually "Needed" to abort, because the next
level does and halts.

(your repeating just shows you have the emotions of a two year ole)

You don't get to compare H to some other H (which has a different
behaving input) to determine need, as there could be an infinite number
of alternates, but you have to compare H to what a "correct simulator"
would do with the exact same input (i.e. paired with this H).

You are just proving that you don't understand the meaning of the words,
and are just LYING about everything you say.

On 3/28/2024 9:27 PM, Richard Damon wrote:
> On 3/28/24 10:03 PM, olcott wrote:
>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>> On 3/28/24 10:32 AM, olcott wrote:
>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>
>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>
>>>>>>>> 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.
>>>>>>>
>>>>>>> Right, except that instead of "would" it is better to say "does".
>>>>>>
>>>>>> H1(D,D) does not need to abort only because H(D,D) does need to
>>>>>> abort.
>>>>>
>>>>> Much bettter.
>>>>>
>>>>
>>>> Richard tries to get away with this:
>>>>
>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>> *its input because some other H somewhere else that did not abort*
>>>> *its input already aborted its input that it never aborted*
>>>>
>>>>
>>>
>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>
>>> The H that DOES abort, turns out to not NEED to abort (but still
>>> does), because the version of it called by D WILL abort, and return 0
>>> and thus D(D) Halts, so this H could have reached a conclusion if
>>> somehow this version of it could not abort (but leave all the other
>>> version as they were).
>>>
>>
>> Because every H in the entire recursive chain has the exact same machine
>> code unless the outermost directly executed one aborts its simulation
>> then none of them do.
>
> So?
>
> If the outer one is coded to abort, then they ALL abort

Counter-factual and you know it.
They would abort if their code is reachable which it is not.

> , and it can be
> shown that NONE of them actually "Needed" to abort, because the next
> level does and halts.
>

Counter-factual and you know it.
They would abort if their code is reachable which it is not.

> (your repeating just shows you have the emotions of a two year ole)
>

Allowing for your ADD.
*If I don't get ridiculous about repeating it*
*you perpetually act like I never said it*

*If I don't get ridiculous about repeating it*
*you perpetually act like I never said it*

*If I don't get ridiculous about repeating it*
*you perpetually act like I never said it*

>
> You don't get to compare H to some other H (which has a different
> behaving input) to determine need, as there could be an infinite number
> of alternates, but you have to compare H to what a "correct simulator"
> would do

*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*

> with the exact same input (i.e. paired with this H).
>
> You are just proving that you don't understand the meaning of the words,
> and are just LYING about everything you say.

--
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/28/24 10:39 PM, olcott wrote:
> On 3/28/2024 9:27 PM, Richard Damon wrote:
>> On 3/28/24 10:03 PM, olcott wrote:
>>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>>> On 3/28/24 10:32 AM, olcott wrote:
>>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>>
>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Right, except that instead of "would" it is better to say "does".
>>>>>>>
>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need to
>>>>>>> abort.
>>>>>>
>>>>>> Much bettter.
>>>>>>
>>>>>
>>>>> Richard tries to get away with this:
>>>>>
>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>> *its input because some other H somewhere else that did not abort*
>>>>> *its input already aborted its input that it never aborted*
>>>>>
>>>>>
>>>>
>>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>>
>>>> The H that DOES abort, turns out to not NEED to abort (but still
>>>> does), because the version of it called by D WILL abort, and return
>>>> 0 and thus D(D) Halts, so this H could have reached a conclusion if
>>>> somehow this version of it could not abort (but leave all the other
>>>> version as they were).
>>>>
>>>
>>> Because every H in the entire recursive chain has the exact same machine
>>> code unless the outermost directly executed one aborts its simulation
>>> then none of them do.
>>
>> So?
>>
>> If the outer one is coded to abort, then they ALL abort
>
> Counter-factual and you know it.
> They would abort if their code is reachable which it is not.

Why isn't it reachable to a correct simulation or direct execution?

>
>> , and it can be shown that NONE of them actually "Needed" to abort,
>> because the next level does and halts.
>>
>
> Counter-factual and you know it.
> They would abort if their code is reachable which it is not.
>

Why isn't it reachable to a correct simulation or direct execution?

You are just proving you logic is based on considering fantasy as the
only reality.

>> (your repeating just shows you have the emotions of a two year ole)
>>
>
> Allowing for your ADD.
> *If I don't get ridiculous about repeating it*
> *you perpetually act like I never said it*

But just repeating it shows you are just being stupid.

>
> *If I don't get ridiculous about repeating it*
> *you perpetually act like I never said it*
>
> *If I don't get ridiculous about repeating it*
> *you perpetually act like I never said it*
>
>>
>> You don't get to compare H to some other H (which has a different
>> behaving input) to determine need, as there could be an infinite
>> number of alternates, but you have to compare H to what a "correct
>> simulator" would do
>
> *AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
> *AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
> *AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
> *AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
> *AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*

Then it needs better eyes.

or, it has NOTHING to do with Comptation Theory.

Which isn't surprizing as you seem to know nothing of computation theory.,

>
>> with the exact same input (i.e. paired with this H).
>>
>> You are just proving that you don't understand the meaning of the
>> words, and are just LYING about everything you say.
>

On 3/28/2024 9:53 PM, Richard Damon wrote:
> On 3/28/24 10:39 PM, olcott wrote:
>> On 3/28/2024 9:27 PM, Richard Damon wrote:
>>> On 3/28/24 10:03 PM, olcott wrote:
>>>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>>>> On 3/28/24 10:32 AM, olcott wrote:
>>>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Right, except that instead of "would" it is better to say "does".
>>>>>>>>
>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need to
>>>>>>>> abort.
>>>>>>>
>>>>>>> Much bettter.
>>>>>>>
>>>>>>
>>>>>> Richard tries to get away with this:
>>>>>>
>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>> *its input already aborted its input that it never aborted*
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>>>
>>>>> The H that DOES abort, turns out to not NEED to abort (but still
>>>>> does), because the version of it called by D WILL abort, and return
>>>>> 0 and thus D(D) Halts, so this H could have reached a conclusion if
>>>>> somehow this version of it could not abort (but leave all the other
>>>>> version as they were).
>>>>>
>>>>
>>>> Because every H in the entire recursive chain has the exact same
>>>> machine
>>>> code unless the outermost directly executed one aborts its simulation
>>>> then none of them do.
>>>
>>> So?
>>>
>>> If the outer one is coded to abort, then they ALL abort
>>
>> Counter-factual and you know it.
>> They would abort if their code is reachable which it is not.
>
> Why isn't it reachable to a correct simulation or direct execution?
>

That is your evil strawman deception away from this abort
decider.

01 void D(ptr x) // ptr is pointer to void function
02 {
03 H(x, x);
04 return;
05 }
06
07 void main()
08 {
09 H(D,D);
10 }

Validation of POD24 as a robust early clinical end point of
poor survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/

An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.

--
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-28 15:39:49 +0000, olcott said:

> On 3/28/2024 9:57 AM, Mikko wrote:
>> On 2024-03-28 14:23:57 +0000, olcott said:
>>
>>> On 3/28/2024 7:54 AM, Mikko wrote:
>>>> On 2024-03-26 14:37:38 +0000, olcott said:
>>>>
>>>
>>> <snip>
>>>
>>>> I have not seen anything that even pretends to be a definition of
>>>> an abort decider.
>>>>
>>>>> *Been providing this definition (with one word changed) for over a year*
>>>>> (a) If simulating abort decider H correctly simulates its input D until
>>>>> H correctly determines that its simulated D would never stop running
>>>>> unless aborted then...
>>>>
>>>> That does not pretend to definition of anything. It uses the term
>>>> "simulationg abort decider" as if that (or at least "abort decider")
>>>> were defined before that.
>>>>
>>>
>>> A simulating abort decider simulates its input until this input matches
>>> one of three non-halting behavior patterns:
>>> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
>>> or the input halts.
>>
>> Is that a definition or a dexcription?
>>
>
> *That is the architectural overview, the definitions are here*
> https://github.com/plolcott/x86utm/blob/master/Halt7.c

On that page the word "abort" is used (in dfferent forms) 5 times
but the term "abort decider" is not defined.

You should quote the definition here or post a more accureate pointer.

--
Mikko

On 3/28/24 11:01 PM, olcott wrote:
> On 3/28/2024 9:53 PM, Richard Damon wrote:
>> On 3/28/24 10:39 PM, olcott wrote:
>>> On 3/28/2024 9:27 PM, Richard Damon wrote:
>>>> On 3/28/24 10:03 PM, olcott wrote:
>>>>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>>>>> On 3/28/24 10:32 AM, olcott wrote:
>>>>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> Right, except that instead of "would" it is better to say "does".
>>>>>>>>>
>>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need to
>>>>>>>>> abort.
>>>>>>>>
>>>>>>>> Much bettter.
>>>>>>>>
>>>>>>>
>>>>>>> Richard tries to get away with this:
>>>>>>>
>>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>>> *its input already aborted its input that it never aborted*
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>>>>
>>>>>> The H that DOES abort, turns out to not NEED to abort (but still
>>>>>> does), because the version of it called by D WILL abort, and
>>>>>> return 0 and thus D(D) Halts, so this H could have reached a
>>>>>> conclusion if somehow this version of it could not abort (but
>>>>>> leave all the other version as they were).
>>>>>>
>>>>>
>>>>> Because every H in the entire recursive chain has the exact same
>>>>> machine
>>>>> code unless the outermost directly executed one aborts its simulation
>>>>> then none of them do.
>>>>
>>>> So?
>>>>
>>>> If the outer one is coded to abort, then they ALL abort
>>>
>>> Counter-factual and you know it.
>>> They would abort if their code is reachable which it is not.
>>
>> Why isn't it reachable to a correct simulation or direct execution?
>>
>
> That is your evil strawman deception away from this abort
> decider.

Which is just YOUR strawman to avoid the question you claim to be
working on.

>
> 01 void D(ptr x) // ptr is pointer to void function
> 02 {
> 03   H(x, x);
> 04   return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09   H(D,D);
> 10 }
>
> Validation of POD24 as a robust early clinical end point of
> poor survival in FL from 5225 patients on 13 clinical trials
> https://pubmed.ncbi.nlm.nih.gov/34614146/

So? Maybe you should just die already then.

>
> An abort decider is relevant to comp theory.
> An abort decider is relevant to comp theory.
> An abort decider is relevant to comp theory.
> An abort decider is relevant to comp theory.
> An abort decider is relevant to comp theory.
>

Since D isn't a Comnpiutation, and H isn't a decider (since it doesn't
return an answer), your statement is clearly a LIE.

On 3/29/2024 6:24 AM, Mikko wrote:
> On 2024-03-28 15:39:49 +0000, olcott said:
>
>> On 3/28/2024 9:57 AM, Mikko wrote:
>>> On 2024-03-28 14:23:57 +0000, olcott said:
>>>
>>>> On 3/28/2024 7:54 AM, Mikko wrote:
>>>>> On 2024-03-26 14:37:38 +0000, olcott said:
>>>>>
>>>>
>>>> <snip>
>>>>
>>>>> I have not seen anything that even pretends to be a definition of
>>>>> an abort decider.
>>>>>
>>>>>> *Been providing this definition (with one word changed) for over a
>>>>>> year*
>>>>>> (a) If simulating abort decider H correctly simulates its input D
>>>>>> until H correctly determines that its simulated D would never stop
>>>>>> running unless aborted then...
>>>>>
>>>>> That does not pretend to definition of anything. It uses the term
>>>>> "simulationg abort decider" as if that (or at least "abort decider")
>>>>> were defined before that.
>>>>>
>>>>
>>>> A simulating abort decider simulates its input until this input
>>>> matches one of three non-halting behavior patterns:
>>>> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
>>>> or the input halts.
>>>
>>> Is that a definition or a dexcription?
>>>
>>
>> *That is the architectural overview, the definitions are here*
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
> On that page the word "abort" is used (in dfferent forms) 5 times
> but the term "abort decider" is not defined.
>
> You should quote the definition here or post a more accureate pointer.
>

01 void D(ptr x) // ptr is pointer to void function
02 {
03 H(x, x);
04 return;
05 }
06
07 void main()
08 {
09 H(D,D);
10 }

H can be construed as an abort decider for the above D.
This gets the exact same result as the original D.
D has been simplified to eliminate distracting details.

--
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/29/2024 8:13 AM, Richard Damon wrote:
> On 3/28/24 11:01 PM, olcott wrote:
>> On 3/28/2024 9:53 PM, Richard Damon wrote:
>>> On 3/28/24 10:39 PM, olcott wrote:
>>>> On 3/28/2024 9:27 PM, Richard Damon wrote:
>>>>> On 3/28/24 10:03 PM, olcott wrote:
>>>>>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>>>>>> On 3/28/24 10:32 AM, olcott wrote:
>>>>>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> Right, except that instead of "would" it is better to say
>>>>>>>>>>> "does".
>>>>>>>>>>
>>>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need
>>>>>>>>>> to abort.
>>>>>>>>>
>>>>>>>>> Much bettter.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Richard tries to get away with this:
>>>>>>>>
>>>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>>>> *its input already aborted its input that it never aborted*
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>>>>>
>>>>>>> The H that DOES abort, turns out to not NEED to abort (but still
>>>>>>> does), because the version of it called by D WILL abort, and
>>>>>>> return 0 and thus D(D) Halts, so this H could have reached a
>>>>>>> conclusion if somehow this version of it could not abort (but
>>>>>>> leave all the other version as they were).
>>>>>>>
>>>>>>
>>>>>> Because every H in the entire recursive chain has the exact same
>>>>>> machine
>>>>>> code unless the outermost directly executed one aborts its simulation
>>>>>> then none of them do.
>>>>>
>>>>> So?
>>>>>
>>>>> If the outer one is coded to abort, then they ALL abort
>>>>
>>>> Counter-factual and you know it.
>>>> They would abort if their code is reachable which it is not.
>>>
>>> Why isn't it reachable to a correct simulation or direct execution?
>>>
>>
>> That is your evil strawman deception away from this abort
>> decider.
>
> Which is just YOUR strawman to avoid the question you claim to be
> working on.
>
>>
>> 01 void D(ptr x) // ptr is pointer to void function
>> 02 {
>> 03   H(x, x);
>> 04   return;
>> 05 }
>> 06
>> 07 void main()
>> 08 {
>> 09   H(D,D);
>> 10 }
>>
>> Validation of POD24 as a robust early clinical end point of
>> poor survival in FL from 5225 patients on 13 clinical trials
>> https://pubmed.ncbi.nlm.nih.gov/34614146/
>
> So? Maybe you should just die already then.
>

You are also a callous bastard too.
By their fruits ye shall know them...

--
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/29/2024 8:13 AM, Richard Damon wrote:
> On 3/28/24 11:01 PM, olcott wrote:
>> On 3/28/2024 9:53 PM, Richard Damon wrote:
>>> On 3/28/24 10:39 PM, olcott wrote:
>>>> On 3/28/2024 9:27 PM, Richard Damon wrote:
>>>>> On 3/28/24 10:03 PM, olcott wrote:
>>>>>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>>>>>> On 3/28/24 10:32 AM, olcott wrote:
>>>>>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> Right, except that instead of "would" it is better to say
>>>>>>>>>>> "does".
>>>>>>>>>>
>>>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need
>>>>>>>>>> to abort.
>>>>>>>>>
>>>>>>>>> Much bettter.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Richard tries to get away with this:
>>>>>>>>
>>>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>>>> *its input already aborted its input that it never aborted*
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>>>>>
>>>>>>> The H that DOES abort, turns out to not NEED to abort (but still
>>>>>>> does), because the version of it called by D WILL abort, and
>>>>>>> return 0 and thus D(D) Halts, so this H could have reached a
>>>>>>> conclusion if somehow this version of it could not abort (but
>>>>>>> leave all the other version as they were).
>>>>>>>
>>>>>>
>>>>>> Because every H in the entire recursive chain has the exact same
>>>>>> machine
>>>>>> code unless the outermost directly executed one aborts its simulation
>>>>>> then none of them do.
>>>>>
>>>>> So?
>>>>>
>>>>> If the outer one is coded to abort, then they ALL abort
>>>>
>>>> Counter-factual and you know it.
>>>> They would abort if their code is reachable which it is not.
>>>
>>> Why isn't it reachable to a correct simulation or direct execution?
>>>
>>
>> That is your evil strawman deception away from this abort
>> decider.
>
> Which is just YOUR strawman to avoid the question you claim to be
> working on.
>
>>
>> 01 void D(ptr x) // ptr is pointer to void function
>> 02 {
>> 03   H(x, x);
>> 04   return;
>> 05 }
>> 06
>> 07 void main()
>> 08 {
>> 09   H(D,D);
>> 10 }
>>
>> Validation of POD24 as a robust early clinical end point of
>> poor survival in FL from 5225 patients on 13 clinical trials
>> https://pubmed.ncbi.nlm.nih.gov/34614146/
>
> So? Maybe you should just die already then.

A clear violation of this law:
https://www.biblegateway.com/verse/en/Galatians%205:14

That could very well have these consequences
https://www.biblegateway.com/verse/en/Galatians%206:7

--
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/29/24 12:09 PM, olcott wrote:
> On 3/29/2024 8:13 AM, Richard Damon wrote:
>> On 3/28/24 11:01 PM, olcott wrote:
>>> On 3/28/2024 9:53 PM, Richard Damon wrote:
>>>> On 3/28/24 10:39 PM, olcott wrote:
>>>>> On 3/28/2024 9:27 PM, Richard Damon wrote:
>>>>>> On 3/28/24 10:03 PM, olcott wrote:
>>>>>>> On 3/28/2024 7:06 PM, Richard Damon wrote:
>>>>>>>> On 3/28/24 10:32 AM, olcott wrote:
>>>>>>>>> On 3/28/2024 7:30 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-26 14:24:37 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/26/2024 3:27 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-25 22:45:37 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, except that instead of "would" it is better to say
>>>>>>>>>>>> "does".
>>>>>>>>>>>
>>>>>>>>>>> H1(D,D) does not need to abort only because H(D,D) does need
>>>>>>>>>>> to abort.
>>>>>>>>>>
>>>>>>>>>> Much bettter.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Richard tries to get away with this:
>>>>>>>>>
>>>>>>>>> *Every H(D,D) that needs to abort its input never needed to abort*
>>>>>>>>> *its input because some other H somewhere else that did not abort*
>>>>>>>>> *its input already aborted its input that it never aborted*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, you keep on lying by changing the words and thus the meaning.
>>>>>>>>
>>>>>>>> The H that DOES abort, turns out to not NEED to abort (but still
>>>>>>>> does), because the version of it called by D WILL abort, and
>>>>>>>> return 0 and thus D(D) Halts, so this H could have reached a
>>>>>>>> conclusion if somehow this version of it could not abort (but
>>>>>>>> leave all the other version as they were).
>>>>>>>>
>>>>>>>
>>>>>>> Because every H in the entire recursive chain has the exact same
>>>>>>> machine
>>>>>>> code unless the outermost directly executed one aborts its
>>>>>>> simulation
>>>>>>> then none of them do.
>>>>>>
>>>>>> So?
>>>>>>
>>>>>> If the outer one is coded to abort, then they ALL abort
>>>>>
>>>>> Counter-factual and you know it.
>>>>> They would abort if their code is reachable which it is not.
>>>>
>>>> Why isn't it reachable to a correct simulation or direct execution?
>>>>
>>>
>>> That is your evil strawman deception away from this abort
>>> decider.
>>
>> Which is just YOUR strawman to avoid the question you claim to be
>> working on.
>>
>>>
>>> 01 void D(ptr x) // ptr is pointer to void function
>>> 02 {
>>> 03   H(x, x);
>>> 04   return;
>>> 05 }
>>> 06
>>> 07 void main()
>>> 08 {
>>> 09   H(D,D);
>>> 10 }
>>>
>>> Validation of POD24 as a robust early clinical end point of
>>> poor survival in FL from 5225 patients on 13 clinical trials
>>> https://pubmed.ncbi.nlm.nih.gov/34614146/
>>
>> So? Maybe you should just die already then.
>
> A clear violation of this law:
> https://www.biblegateway.com/verse/en/Galatians%205:14
>
> That could very well have these consequences
> https://www.biblegateway.com/verse/en/Galatians%206:7
>

But if my prodding has a chance of getting you to repent, then it IS out
of "love" for you.

On 3/29/24 10:44 AM, olcott wrote:
> On 3/29/2024 6:24 AM, Mikko wrote:
>> On 2024-03-28 15:39:49 +0000, olcott said:
>>
>>> On 3/28/2024 9:57 AM, Mikko wrote:
>>>> On 2024-03-28 14:23:57 +0000, olcott said:
>>>>
>>>>> On 3/28/2024 7:54 AM, Mikko wrote:
>>>>>> On 2024-03-26 14:37:38 +0000, olcott said:
>>>>>>
>>>>>
>>>>> <snip>
>>>>>
>>>>>> I have not seen anything that even pretends to be a definition of
>>>>>> an abort decider.
>>>>>>
>>>>>>> *Been providing this definition (with one word changed) for over
>>>>>>> a year*
>>>>>>> (a) If simulating abort decider H correctly simulates its input D
>>>>>>> until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then...
>>>>>>
>>>>>> That does not pretend to definition of anything. It uses the term
>>>>>> "simulationg abort decider" as if that (or at least "abort decider")
>>>>>> were defined before that.
>>>>>>
>>>>>
>>>>> A simulating abort decider simulates its input until this input
>>>>> matches one of three non-halting behavior patterns:
>>>>> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
>>>>> or the input halts.
>>>>
>>>> Is that a definition or a dexcription?
>>>>
>>>
>>> *That is the architectural overview, the definitions are here*
>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>
>> On that page the word "abort" is used (in dfferent forms) 5 times
>> but the term "abort decider" is not defined.
>>
>> You should quote the definition here or post a more accureate pointer.
>>
>
> 01 void D(ptr x) // ptr is pointer to void function
> 02 {
> 03   H(x, x);
> 04   return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09   H(D,D);
> 10 }
>
> H can be construed as an abort decider for the above D.
> This gets the exact same result as the original D.
> D has been simplified to eliminate distracting details.
>

Except that your "abort decider" definition isn't a "decider" that has
requires a non-trivial answer.

And H that always immediately aborts and says it did is trivially correct.

D, is also, not a valid input, as it isn't a "Computation", as its
behavior is dependent on which version of H you give it. (For instance,
an H that never aborts cause D to be non-halting, and thus needed to be
aborted, but an H that always answers, makes D halting, and thus H
doesn't need to abort it.

On 3/29/2024 12:02 PM, Richard Damon wrote:
> On 3/29/24 10:44 AM, olcott wrote:
>> On 3/29/2024 6:24 AM, Mikko wrote:
>>> On 2024-03-28 15:39:49 +0000, olcott said:
>>>
>>>> On 3/28/2024 9:57 AM, Mikko wrote:
>>>>> On 2024-03-28 14:23:57 +0000, olcott said:
>>>>>
>>>>>> On 3/28/2024 7:54 AM, Mikko wrote:
>>>>>>> On 2024-03-26 14:37:38 +0000, olcott said:
>>>>>>>
>>>>>>
>>>>>> <snip>
>>>>>>
>>>>>>> I have not seen anything that even pretends to be a definition of
>>>>>>> an abort decider.
>>>>>>>
>>>>>>>> *Been providing this definition (with one word changed) for over
>>>>>>>> a year*
>>>>>>>> (a) If simulating abort decider H correctly simulates its input
>>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>>> stop running unless aborted then...
>>>>>>>
>>>>>>> That does not pretend to definition of anything. It uses the term
>>>>>>> "simulationg abort decider" as if that (or at least "abort decider")
>>>>>>> were defined before that.
>>>>>>>
>>>>>>
>>>>>> A simulating abort decider simulates its input until this input
>>>>>> matches one of three non-halting behavior patterns:
>>>>>> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
>>>>>> or the input halts.
>>>>>
>>>>> Is that a definition or a dexcription?
>>>>>
>>>>
>>>> *That is the architectural overview, the definitions are here*
>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>
>>> On that page the word "abort" is used (in dfferent forms) 5 times
>>> but the term "abort decider" is not defined.
>>>
>>> You should quote the definition here or post a more accureate pointer.
>>>
>>
>> 01 void D(ptr x) // ptr is pointer to void function
>> 02 {
>> 03   H(x, x);
>> 04   return;
>> 05 }
>> 06
>> 07 void main()
>> 08 {
>> 09   H(D,D);
>> 10 }
>>
>> H can be construed as an abort decider for the above D.
>> This gets the exact same result as the original D.
>> D has been simplified to eliminate distracting details.
>>
>
> Except that your "abort decider" definition isn't a "decider" that has
> requires a non-trivial answer.
>
> And H that always immediately aborts and says it did is trivially correct.
>
> D, is also, not a valid input, as it isn't a "Computation", as its
> behavior is dependent on which version of H you give it. (For instance,
> an H that never aborts cause D to be non-halting, and thus needed to be
> aborted, but an H that always answers, makes D halting, and thus H
> doesn't need to abort it.

When you try to explain the details of this you contradict yourself.

--
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/29/24 1:07 PM, olcott wrote:
> On 3/29/2024 12:02 PM, Richard Damon wrote:
>> On 3/29/24 10:44 AM, olcott wrote:
>>> On 3/29/2024 6:24 AM, Mikko wrote:
>>>> On 2024-03-28 15:39:49 +0000, olcott said:
>>>>
>>>>> On 3/28/2024 9:57 AM, Mikko wrote:
>>>>>> On 2024-03-28 14:23:57 +0000, olcott said:
>>>>>>
>>>>>>> On 3/28/2024 7:54 AM, Mikko wrote:
>>>>>>>> On 2024-03-26 14:37:38 +0000, olcott said:
>>>>>>>>
>>>>>>>
>>>>>>> <snip>
>>>>>>>
>>>>>>>> I have not seen anything that even pretends to be a definition of
>>>>>>>> an abort decider.
>>>>>>>>
>>>>>>>>> *Been providing this definition (with one word changed) for
>>>>>>>>> over a year*
>>>>>>>>> (a) If simulating abort decider H correctly simulates its input
>>>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>>>> stop running unless aborted then...
>>>>>>>>
>>>>>>>> That does not pretend to definition of anything. It uses the term
>>>>>>>> "simulationg abort decider" as if that (or at least "abort
>>>>>>>> decider")
>>>>>>>> were defined before that.
>>>>>>>>
>>>>>>>
>>>>>>> A simulating abort decider simulates its input until this input
>>>>>>> matches one of three non-halting behavior patterns:
>>>>>>> (a) Infinite loop (b) Infinite recursion (c) recursive simulation.
>>>>>>> or the input halts.
>>>>>>
>>>>>> Is that a definition or a dexcription?
>>>>>>
>>>>>
>>>>> *That is the architectural overview, the definitions are here*
>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>
>>>> On that page the word "abort" is used (in dfferent forms) 5 times
>>>> but the term "abort decider" is not defined.
>>>>
>>>> You should quote the definition here or post a more accureate pointer.
>>>>
>>>
>>> 01 void D(ptr x) // ptr is pointer to void function
>>> 02 {
>>> 03   H(x, x);
>>> 04   return;
>>> 05 }
>>> 06
>>> 07 void main()
>>> 08 {
>>> 09   H(D,D);
>>> 10 }
>>>
>>> H can be construed as an abort decider for the above D.
>>> This gets the exact same result as the original D.
>>> D has been simplified to eliminate distracting details.
>>>
>>
>> Except that your "abort decider" definition isn't a "decider" that has
>> requires a non-trivial answer.
>>
>> And H that always immediately aborts and says it did is trivially
>> correct.
>>
>> D, is also, not a valid input, as it isn't a "Computation", as its
>> behavior is dependent on which version of H you give it. (For
>> instance, an H that never aborts cause D to be non-halting, and thus
>> needed to be aborted, but an H that always answers, makes D halting,
>> and thus H doesn't need to abort it.
>
> When you try to explain the details of this you contradict yourself.
>

WHERE?

SPECIFICS, or you are just lying via bluster.