On 2024-03-26 14:37:38 +0000, olcott said:
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.
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.
*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.
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:The halting problem is about whether a program halts not whether >>>>>>> a "correct simulation" of that program halts.
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 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.
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.
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:Right, No H can simulate the input that is based on it to the >>>>>>>>> point that it halts.
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:Right, except that instead of "would" it is better to say >>>>>>>>>>>>> "does".
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:The halting problem is about computing the mapping from >>>>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> Right, and since D,D specifies the program D(D) and >>>>>>>>>>>>>>>>>>> that Halts,The halting problem is about whether a program halts >>>>>>>>>>>>>>>>> not whether a "correct simulation" of that program 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?
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. >>>>>>>>>>>>>
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? >>>>>>>>>
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,
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?
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:Right, No H can simulate the input that is based on it to the >>>>>>>>>> point that it halts.
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:The halting problem is about computing the mapping from >>>>>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> Right, and since D,D specifies the program D(D) and >>>>>>>>>>>>>>>>>>>> that Halts,The halting problem is about whether a program halts >>>>>>>>>>>>>>>>>> not whether a "correct simulation" of that program 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?
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? >>>>>>>>>>
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...
Maybe you didn't lie about this?
Instead you may have exaggerated your current programming skill?
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.
You can cheat like Mike suggests in a debugger and change the outermost
H so that it doesn't abort and thus violate the definition of the
problem that requires every H to have identical behavior. Violating
the definition of the problem IS CHEATING.
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:The halting problem is about whether a program halts not whether >>>>>>>> a "correct simulation" of that program halts.
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 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*
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.
01 void B(ptr x) // ptr is pointer to void functionBut it does, so this is just a false predicate.
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)
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.
As soon as line 03 would be executed A sees that B would call
itself with its same input, then A aborts B.
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:The halting problem is about whether a program halts not
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?
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/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:Much bettter.
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:The halting problem is about whether a program halts not
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?
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. >>>>
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.
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:H1(D,D) does not need to abort only because H(D,D) does need to
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:The halting problem is about whether a program halts not >>>>>>>>>>> whether a "correct simulation" of that program halts.
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 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". >>>>>>
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:H1(D,D) does not need to abort only because H(D,D) does need to >>>>>>> abort.
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>
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:The halting problem is about whether a program halts not >>>>>>>>>>>> whether a "correct simulation" of that program halts.
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 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. >>>>>>>>
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.
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:H1(D,D) does not need to abort only because H(D,D) does need to >>>>>>>> abort.
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>>
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:The halting problem is about computing the mapping from the >>>>>>>>>>>> inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>
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?
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. >>>>>>>>>
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?
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 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:H1(D,D) does not need to abort only because H(D,D) does need to >>>>>>>>> abort.
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>>>
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:The halting problem is about computing the mapping from the >>>>>>>>>>>>> inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>
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?
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. >>>>>>>>>>
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.
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.
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:Right, except that instead of "would" it is better to say >>>>>>>>>>> "does".
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:The halting problem is about computing the mapping from >>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>>
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?
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. >>>>>>>>>>>
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.
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:Right, except that instead of "would" it is better to say >>>>>>>>>>> "does".
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:The halting problem is about computing the mapping from >>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>>
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?
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. >>>>>>>>>>>
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.
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:Right, except that instead of "would" it is better to say >>>>>>>>>>>> "does".
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:The halting problem is about computing the mapping from >>>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>>>
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?
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. >>>>>>>>>>>>
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
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.
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.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 912 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 165:14:16 |
| Calls: | 12,138 |
| Calls today: | 1 |
| Files: | 186,514 |
| Messages: | 2,231,107 |