On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the halting >>>>>>>>> problem has been intentionally defined to be unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct execution of D(D). >>>>>>>>>
Do you believe it's impossible or possible to write a program
that reports whether the direct execution of its input would halt? >>>>>>>>
When-so-ever an input calls its own termination analyzer
in recursive simulation then H is not allowed to report
on different behavior than the behavior that it sees.
Every H that must abort its simulation of any input D to prevent >>>>>>> its own infinite execution is necessarily correct to reject D as >>>>>>> non-halting.
Do you believe it's impossible or possible to write a program that >>>>>> reports whether the direct execution of its input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual property
of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the halting >>>>>>>>> problem has been intentionally defined to be unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct execution of D(D). >>>>>>>>>
Do you believe it's impossible or possible to write a program
that reports whether the direct execution of its input would halt? >>>>>>>>
When-so-ever an input calls its own termination analyzer
in recursive simulation then H is not allowed to report
on different behavior than the behavior that it sees.
Every H that must abort its simulation of any input D to prevent >>>>>>> its own infinite execution is necessarily correct to reject D as >>>>>>> non-halting.
Do you believe it's impossible or possible to write a program that >>>>>> reports whether the direct execution of its input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual property
of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:*It in incorrect for H to do this in some cases*
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the halting >>>>>>>>>>> problem has been intentionally defined to be unsatisfiable >>>>>>>>>>> when H is required to report on the direct execution of D(D). >>>>>>>>>>>https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
Do you believe it's impossible or possible to write a program >>>>>>>>>> that reports whether the direct execution of its input would >>>>>>>>>> halt?
When-so-ever an input calls its own termination analyzer
in recursive simulation then H is not allowed to report
on different behavior than the behavior that it sees.
Every H that must abort its simulation of any input D to
prevent its own infinite execution is necessarily correct to >>>>>>>>> reject D as non-halting.
Do you believe it's impossible or possible to write a program
that reports whether the direct execution of its input would halt? >>>>>>>
*That would make H a liar*
Why would it be incorrect to answer the question actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual
property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D DOES NOT specify recursive simulation to H1.
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:Does D specify halting behavior to H?
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the halting >>>>>>>>>>>>> problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>> when H is required to report on the direct execution of D(D). >>>>>>>>>>>>>https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
Do you believe it's impossible or possible to write a
program that reports whether the direct execution of its >>>>>>>>>>>> input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>> in recursive simulation then H is not allowed to report
on different behavior than the behavior that it sees.
Every H that must abort its simulation of any input D to >>>>>>>>>>> prevent its own infinite execution is necessarily correct to >>>>>>>>>>> reject D as non-halting.
Do you believe it's impossible or possible to write a program >>>>>>>>>> that reports whether the direct execution of its input would >>>>>>>>>> halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually asked? >>>>>>>
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual
property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually does.
When-so-ever any simulating termination analyzer H must abort the
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
On 1/27/2024 6:09 PM, Richard Damon wrote:
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:Does D specify halting behavior to H?
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the halting >>>>>>>>>>>>>>> problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>>>> when H is required to report on the direct execution of >>>>>>>>>>>>>>> D(D).https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>> input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>
Every H that must abort its simulation of any input D to >>>>>>>>>>>>> prevent its own infinite execution is necessarily correct >>>>>>>>>>>>> to reject D as non-halting.
Do you believe it's impossible or possible to write a
program that reports whether the direct execution of its >>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually asked? >>>>>>>>>
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual
property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually does. >>>>
When-so-ever any simulating termination analyzer H must abort the
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show
this, D doesn't change and still refers to the H that did abort.
So you are claiming that you just don't understand that every H that
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
On 1/27/2024 6:09 PM, Richard Damon wrote:
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:Does D specify halting behavior to H?
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the halting >>>>>>>>>>>>>>> problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>>>> when H is required to report on the direct execution of >>>>>>>>>>>>>>> D(D).https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>> input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>
Every H that must abort its simulation of any input D to >>>>>>>>>>>>> prevent its own infinite execution is necessarily correct >>>>>>>>>>>>> to reject D as non-halting.
Do you believe it's impossible or possible to write a
program that reports whether the direct execution of its >>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually asked? >>>>>>>>>
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual
property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually does. >>>>
When-so-ever any simulating termination analyzer H must abort the
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show
this, D doesn't change and still refers to the H that did abort.
So you are claiming that you just don't understand that every H that
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote just
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the >>>>>>>>>>>>>>>>> haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>>>>>> when H is required to report on the direct execution of >>>>>>>>>>>>>>>>> D(D).
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>>>> input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D to >>>>>>>>>>>>>>> prevent its own infinite execution is necessarily correct >>>>>>>>>>>>>>> to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually >>>>>>>>>>>> asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual >>>>>>>>>> property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually
does.
When-so-ever any simulating termination analyzer H must abort the
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show
this, D doesn't change and still refers to the H that did abort.
So you are claiming that you just don't understand that every H that
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
On 1/27/2024 7:26 PM, Richard Damon wrote:
On 1/27/24 7:32 PM, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the >>>>>>>>>>>>>>>>> haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>>>>>> when H is required to report on the direct execution of >>>>>>>>>>>>>>>>> D(D).
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>>>> input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D to >>>>>>>>>>>>>>> prevent its own infinite execution is necessarily correct >>>>>>>>>>>>>>> to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually >>>>>>>>>>>> asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual >>>>>>>>>> property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually
does.
When-so-ever any simulating termination analyzer H must abort the
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show
this, D doesn't change and still refers to the H that did abort.
So you are claiming that you just don't understand that every H that
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
Because that statement is just false, based on your incorrect
implementation of the D/H pair.
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 }
Whenever I ask you to prove it you do not because
you know that you are lying.
Show how any implementation of H that correctly simulates
D can possibly stop running without aborting its simulation
of D. (running out of memory counts as aborting).
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote just
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the >>>>>>>>>>>>>>>>> haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>>>>>> when H is required to report on the direct execution of >>>>>>>>>>>>>>>>> D(D).
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>>>> input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D to >>>>>>>>>>>>>>> prevent its own infinite execution is necessarily correct >>>>>>>>>>>>>>> to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases*
*That would make H a liar*
Why would it be incorrect to answer the question actually >>>>>>>>>>>> asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual >>>>>>>>>> property of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually
does.
When-so-ever any simulating termination analyzer H must abort the
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show
this, D doesn't change and still refers to the H that did abort.
So you are claiming that you just don't understand that every H that
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote
On 1/27/24 6:39 PM, olcott wrote:So you are claiming that you just don't understand that every H that >>>>> can possibly exist must abort its simulated D because this is simply >>>>> over your head because you are not very smart?
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the >>>>>>>>>>>>>>>>>>> haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct execution >>>>>>>>>>>>>>>>>>> of D(D).
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>>>> program that reports whether the direct execution of >>>>>>>>>>>>>>>>>> its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D >>>>>>>>>>>>>>>>> to prevent its own infinite execution is necessarily >>>>>>>>>>>>>>>>> correct to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question actually >>>>>>>>>>>>>> asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually >>>>>>>> does.
When-so-ever any simulating termination analyzer H must abort the >>>>>>> simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and
thus into the program of D, so when you "alter" H to not abort to
show this, D doesn't change and still refers to the H that did abort. >>>>>
just one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the H
that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
On 1/28/2024 11:17 AM, immibis wrote:
On 1/28/24 16:28, olcott wrote:
On 1/28/2024 6:12 AM, immibis wrote:You don't seem to understand the idea of a proof template. It
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that >>>>>>>>>>>>>>>>>>>>> the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to write >>>>>>>>>>>>>>>>>>>> a program that reports whether the direct execution >>>>>>>>>>>>>>>>>>>> of its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D >>>>>>>>>>>>>>>>>>> to prevent its own infinite execution is necessarily >>>>>>>>>>>>>>>>>>> correct to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>>>> program that reports whether the direct execution of >>>>>>>>>>>>>>>>>> its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H
actually does.
When-so-ever any simulating termination analyzer H must abort the >>>>>>>>> simulation of its input D to prevent its own infinite execution >>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and >>>>>>>> thus into the program of D, so when you "alter" H to not abort >>>>>>>> to show this, D doesn't change and still refers to the H that
did abort.
So you are claiming that you just don't understand that every H that >>>>>>> can possibly exist must abort its simulated D because this is simply >>>>>>> over your head because you are not very smart?
just one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring >>>>> every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the
H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
generates a lot of proofs. Each proof applies to one program. You
can't use half of the proof with one program, and half with another
program.
Not at all. This is ALL your mistake.
On 1/28/2024 11:17 AM, immibis wrote:
On 1/28/24 16:28, olcott wrote:
On 1/28/2024 6:12 AM, immibis wrote:You don't seem to understand the idea of a proof template. It
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that >>>>>>>>>>>>>>>>>>>>> the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to write >>>>>>>>>>>>>>>>>>>> a program that reports whether the direct execution >>>>>>>>>>>>>>>>>>>> of its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D >>>>>>>>>>>>>>>>>>> to prevent its own infinite execution is necessarily >>>>>>>>>>>>>>>>>>> correct to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>>>> program that reports whether the direct execution of >>>>>>>>>>>>>>>>>> its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H
actually does.
When-so-ever any simulating termination analyzer H must abort the >>>>>>>>> simulation of its input D to prevent its own infinite execution >>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and >>>>>>>> thus into the program of D, so when you "alter" H to not abort >>>>>>>> to show this, D doesn't change and still refers to the H that
did abort.
So you are claiming that you just don't understand that every H that >>>>>>> can possibly exist must abort its simulated D because this is simply >>>>>>> over your head because you are not very smart?
just one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring >>>>> every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the
H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
generates a lot of proofs. Each proof applies to one program. You
can't use half of the proof with one program, and half with another
program.
Not at all. This is ALL your mistake.
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote just
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:Does D specify halting behavior to H?
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>> *That would make H a liar*
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be unsatisfiable >>>>>>>>>>>>>>>>>>> when H is required to report on the direct execution of D(D).
Do you believe it's impossible or possible to write a program that
reports whether the direct execution of its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D to prevent its
own infinite execution is necessarily correct to reject D as >>>>>>>>>>>>>>>>> non-halting.
Do you believe it's impossible or possible to write a program that
reports whether the direct execution of its input would halt? >>>>>>>>>>>>>>>
Why would it be incorrect to answer the question actually asked? >>>>>>>>>>>>>
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual property
of Halting is independent of who you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually does. >>>>>>>>
When-so-ever any simulating termination analyzer H must abort the >>>>>>> simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and thus >>>>>> into the program of D, so when you "alter" H to not abort to show this, >>>>>> D doesn't change and still refers to the H that did abort.
So you are claiming that you just don't understand that every H that >>>>> can possibly exist must abort its simulated D because this is simply >>>>> over your head because you are not very smart?
one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the H
that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote
On 1/27/24 6:39 PM, olcott wrote:So you are claiming that you just don't understand that every H that >>>>> can possibly exist must abort its simulated D because this is simply >>>>> over your head because you are not very smart?
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that the >>>>>>>>>>>>>>>>>>> haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct execution >>>>>>>>>>>>>>>>>>> of D(D).
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>>>> program that reports whether the direct execution of >>>>>>>>>>>>>>>>>> its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D >>>>>>>>>>>>>>>>> to prevent its own infinite execution is necessarily >>>>>>>>>>>>>>>>> correct to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>> program that reports whether the direct execution of its >>>>>>>>>>>>>>>> input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question actually >>>>>>>>>>>>>> asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort
its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H actually >>>>>>>> does.
When-so-ever any simulating termination analyzer H must abort the >>>>>>> simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as
non-halting.
And the decision to abort was encoded in the program of H, and
thus into the program of D, so when you "alter" H to not abort to
show this, D doesn't change and still refers to the H that did abort. >>>>>
just one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the H
that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that >>>>>>>>>>>>>>>>>>>>> the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to write >>>>>>>>>>>>>>>>>>>> a program that reports whether the direct execution >>>>>>>>>>>>>>>>>>>> of its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D >>>>>>>>>>>>>>>>>>> to prevent its own infinite execution is necessarily >>>>>>>>>>>>>>>>>>> correct to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>>>> program that reports whether the direct execution of >>>>>>>>>>>>>>>>>> its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H
actually does.
When-so-ever any simulating termination analyzer H must abort the >>>>>>>>> simulation of its input D to prevent its own infinite execution >>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and >>>>>>>> thus into the program of D, so when you "alter" H to not abort >>>>>>>> to show this, D doesn't change and still refers to the H that
did abort.
So you are claiming that you just don't understand that every H that >>>>>>> can possibly exist must abort its simulated D because this is simply >>>>>>> over your head because you are not very smart?
just one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring >>>>> every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the
H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all the
same name.
Just as he uses the same name for different halt deciders, some of
which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can imagine
three candidates:
Hss: A simple simulating halt decider, which does not abort. It is
clear it can report only about programs which terminate normally.In
this case it returns 'halting'. It cannot return 'non-halting' in a
finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of this
discussion, we ignore that it very improbable that Han will be
possible to recognize all variations of the algorithm, because we
stick for the moment to the template mentioned above. Similarly it
will not be easy to detect always that the program does the opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite recursion,
not Han.
Hah: A simulating halt decider, similar to Han, but when it recognizes
that the same algorithm is used to do the opposite, it aborts and
returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite recursion,
not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'. Because,
for Hss 'keeps looping' is sufficient, whereas for Han and Hah 'does
not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide on a
template, because different instantiations of a template can do
different things. Therefore, from these three candidates the template
can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss does
not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with 'unless',
because it is clear that only Dss is involved in infinite recursion
within the algorithm of Hss. Dan and Dah are not, because Han and Hah
are not.
Three programs and three candidate halt deciders. That results in nine
combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of Hah
returns to the simulation of Dah, which does not end. So Hss never
returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss is
not aborted. So, does Han recognize the infinite recursion? That
depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports
'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah is
not aborted. The simulation of Hah returns with 'halting'. Does Han
subsequently recognize that D starts an infinite loop? That depends on
details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss is
not aborted. So, does Hah recognize the infinite recursion? That
depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han is
not aborted. The simulation of Ha returns with 'non-halting'. The
simulation of D will end normally and Hah will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are definitely
able to report a correct status. we also see that the three most
important ones Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
return the correct status.
May I suggest that we stick to these names, instead of using the same
names D and H for different things? That would make the discussion
more transparent. And maybe olcott can tell which case is in
discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of the
other combinations. Are we talking about an aborting, or a
non-aborting decider? I ask this, because sentence fragments like
'keeps looping unless aborted', suggests that it is not always
aborted, so it is not clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote >>>>>>>> just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>> When-so-ever any simulating termination analyzer H must abort >>>>>>>>>>> the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that >>>>>>>>>>>>>>>>>>>>>>> the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input >>>>>>>>>>>>>>>>>>>>> D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to write >>>>>>>>>>>>>>>>>>>> a program that reports whether the direct execution >>>>>>>>>>>>>>>>>>>> of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite execution >>>>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and >>>>>>>>>> thus into the program of D, so when you "alter" H to not abort >>>>>>>>>> to show this, D doesn't change and still refers to the H that >>>>>>>>>> did abort.
So you are claiming that you just don't understand that every H >>>>>>>>> that
can possibly exist must abort its simulated D because this is >>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for
the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all
the same name.
Just as he uses the same name for different halt deciders, some of
which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can imagine
three candidates:
Hss: A simple simulating halt decider, which does not abort. It is
clear it can report only about programs which terminate normally.In
this case it returns 'halting'. It cannot return 'non-halting' in a
finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of this
discussion, we ignore that it very improbable that Han will be
possible to recognize all variations of the algorithm, because we
stick for the moment to the template mentioned above. Similarly it
will not be easy to detect always that the program does the opposite.) >>>>
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'. Because,
for Hss 'keeps looping' is sufficient, whereas for Han and Hah 'does
not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide on
a template, because different instantiations of a template can do
different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with 'unless',
because it is clear that only Dss is involved in infinite recursion
within the algorithm of Hss. Dan and Dah are not, because Han and
Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss is
not aborted. So, does Han recognize the infinite recursion? That
depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports
'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah is
not aborted. The simulation of Hah returns with 'halting'. Does Han
subsequently recognize that D starts an infinite loop? That depends
on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss is
not aborted. So, does Hah recognize the infinite recursion? That
depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han is
not aborted. The simulation of Ha returns with 'non-halting'. The
simulation of D will end normally and Hah will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are definitely
able to report a correct status. we also see that the three most
important ones Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case is
in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of
the other combinations. Are we talking about an aborting, or a
non-aborting decider? I ask this, because sentence fragments like
'keeps looping unless aborted', suggests that it is not always
aborted, so it is not clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not abort, or
one of the aborting ones?
*The infinite set of every H that matches this template*
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to abort this simulation and
report that *D DOES NOT HALT*
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not abort, or
one of the aborting ones?
*The infinite set of every H that matches this template*
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to abort this simulation and
report that *D DOES NOT HALT*
On 10/13/2022 11:46 AM, olcott wrote:
MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.
On 1/29/2024 2:04 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 20:24 schreef olcott:
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:The Peter Linz proof uses a program template simultaneously >>>>>>>>>>> referring
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>>>> wrote just one H, not every one that could possibly exist. >>>>>>>>>>>
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>>>> that the halting
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the >>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed >>>>>>>>>>>>>>>>>>>>>>>>> to report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution >>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H? >>>>>>>>>>>>>>>>>>>>> No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as >>>>>>>>>>>>>>>>>>>> the actual property of Halting is independent of who >>>>>>>>>>>>>>>>>>>> you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt. >>>>>>>>>>>>>>>>>
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this >>>>>>>>>>>>>>> input as
non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>>>> and thus into the program of D, so when you "alter" H to >>>>>>>>>>>>>> not abort to show this, D doesn't change and still refers >>>>>>>>>>>>>> to the H that did abort.
So you are claiming that you just don't understand that >>>>>>>>>>>>> every H that
can possibly exist must abort its simulated D because this >>>>>>>>>>>>> is simply
over your head because you are not very smart?
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof >>>>>>>>>> for the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them >>>>>>>> all the same name.
Just as he uses the same name for different halt deciders, some >>>>>>>> of which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders? >>>>>>>> Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It >>>>>>>> is clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the >>>>>>>> program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of >>>>>>>> this discussion, we ignore that it very improbable that Han will >>>>>>>> be possible to recognize all variations of the algorithm,
because we stick for the moment to the template mentioned above. >>>>>>>> Similarly it will not be easy to detect always that the program >>>>>>>> does the opposite.)
It is clear that Han is wrong if it assumes that Han will do an >>>>>>>> infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, >>>>>>>> it aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an >>>>>>>> infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated >>>>>>>> sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han >>>>>>>> and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide >>>>>>>> on a template, because different instantiations of a template
can do different things. Therefore, from these three candidates >>>>>>>> the template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because
Hss does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt. >>>>>>>>
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are >>>>>>>> not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results >>>>>>>> in nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends >>>>>>>> normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation >>>>>>>> of Hah returns to the simulation of Dah, which does not end. So >>>>>>>> Hss never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of
Hss is not aborted. So, does Han recognize the infinite
recursion? That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and
reports 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of
Hah is not aborted. The simulation of Hah returns with
'halting'. Does Han subsequently recognize that D starts an
infinite loop? That depends on details not provides by olcott. >>>>>>>>
Hah(Dss,Dss): Hah is different from Hss, so the simulation of
Hss is not aborted. So, does Hah recognize the infinite
recursion? That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of
Han is not aborted. The simulation of Ha returns with
'non-halting'. The simulation of D will end normally and Hah
will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and
reports 'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the >>>>>>>> three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the >>>>>>>> same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which
case is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or
Hah(Dah,Dah), or one of the other combinations. Are we talking >>>>>>>> about an aborting, or a non-aborting decider? I ask this,
because sentence fragments like 'keeps looping unless aborted', >>>>>>>> suggests that it is not always aborted, so it is not clear
whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct
simulation of
input D that itself would never stop running unless it aborts its >>>>>>> simulation of D is necessarily correct to report that *D DOES NOT >>>>>>> HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not abort,
or one of the aborting ones?
*The infinite set of every H that matches this template*
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to abort this simulation and
report that *D DOES NOT HALT*
Please, make up your mind. Does it never stop running, or does it
abort? It cannot do both.
It correctly determines that its input never halts thus providing
H the criteria it needs to abort its simulation and force it to
terminate abnormally, thus still never halt.
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not abort, or
one of the aborting ones?
*The infinite set of every H that matches this template*
On 1/29/2024 4:10 PM, immibis wrote:
On 1/29/24 20:24, olcott wrote:
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
And which way is it? Hss, HAn, or HAh? The one that does not abort,
or one of the aborting ones?
*The infinite set of every H that matches this template*
So your program H is actually an infinite set of programs?
I didn't say that Dumbo.
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four (4)
times.
There is only one single relevant detail and changing the subject away
from this is off topic thus must be ignored. I tolerated this from
Ben Bacarisse for a dozen years.
*Ben was a master of the change-the-subject rebuttal*
On 1/29/2024 4:09 PM, immibis wrote:
On 1/29/24 21:56, olcott wrote:
On 1/29/2024 2:04 PM, Fred. Zwarts wrote:Turing machines cannot terminate abnormally.
Op 29.jan.2024 om 20:24 schreef olcott:
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:The Peter Linz proof uses a program template simultaneously >>>>>>>>>>>>> referring
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>>>>>> wrote just one H, not every one that could possibly exist. >>>>>>>>>>>>>
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the halting
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*problem has been intentionally defined to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> be unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible >>>>>>>>>>>>>>>>>>>>>>>>>>>> to write a program that reports whether the >>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own >>>>>>>>>>>>>>>>>>>>>>>>>>> termination analyzer
in recursive simulation then H is not allowed >>>>>>>>>>>>>>>>>>>>>>>>>>> to report
on different behavior than the behavior that >>>>>>>>>>>>>>>>>>>>>>>>>>> it sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution >>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to reject D as >>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the >>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>>
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H? >>>>>>>>>>>>>>>>>>>>>>> No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as >>>>>>>>>>>>>>>>>>>>>> the actual property of Halting is independent of >>>>>>>>>>>>>>>>>>>>>> who you ask.
D specifies infinite recursion to H. >>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt. >>>>>>>>>>>>>>>>>>>
D only specifies as much recursive simulation to H as >>>>>>>>>>>>>>>>>> H actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this >>>>>>>>>>>>>>>>> input as
non-halting.
And the decision to abort was encoded in the program of >>>>>>>>>>>>>>>> H, and thus into the program of D, so when you "alter" H >>>>>>>>>>>>>>>> to not abort to show this, D doesn't change and still >>>>>>>>>>>>>>>> refers to the H that did abort.
So you are claiming that you just don't understand that >>>>>>>>>>>>>>> every H that
can possibly exist must abort its simulated D because >>>>>>>>>>>>>>> this is simply
over your head because you are not very smart?
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof >>>>>>>>>>>> for the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them >>>>>>>>>> all the same name.
Just as he uses the same name for different halt deciders, >>>>>>>>>> some of which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders? >>>>>>>>>> Here we limit ourselves to simulating halt deciders. We can >>>>>>>>>> imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. >>>>>>>>>> It is clear it can report only about programs which terminate >>>>>>>>>> normally.In this case it returns 'halting'. It cannot return >>>>>>>>>> 'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that >>>>>>>>>> the program uses the same algorithm that is used in Han to do >>>>>>>>>> the opposite, it aborts and returns 'non-halting'. (For the >>>>>>>>>> sake of this discussion, we ignore that it very improbable >>>>>>>>>> that Han will be possible to recognize all variations of the >>>>>>>>>> algorithm, because we stick for the moment to the template >>>>>>>>>> mentioned above. Similarly it will not be easy to detect
always that the program does the opposite.)
It is clear that Han is wrong if it assumes that Han will do >>>>>>>>>> an infinite recursion, because it is Hss that does an infinite >>>>>>>>>> recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it >>>>>>>>>> recognizes that the same algorithm is used to do the opposite, >>>>>>>>>> it aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do >>>>>>>>>> an infinite recursion, because it is Hss that does an infinite >>>>>>>>>> recursion, not Hah.
Using these names it is no longer needed to use
overcomplicated sentence fragments, such as 'keeps looping >>>>>>>>>> unless aborted'. Because, for Hss 'keeps looping' is
sufficient, whereas for Han and Hah 'does not loop, because >>>>>>>>>> aborted' is more clear.
A halting decider needs a program to decide on. It cannot
decide on a template, because different instantiations of a >>>>>>>>>> template can do different things. Therefore, from these three >>>>>>>>>> candidates the template can be used to create three programs: >>>>>>>>>>
Dss: based on Hss. It is clear that it does not halt, because >>>>>>>>>> Hss does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts. >>>>>>>>>> Dah: based on Hah. Han returns 'halting', so Dan does not halt. >>>>>>>>>>
Again, we do no longer need overcomplicated sentences with >>>>>>>>>> 'unless', because it is clear that only Dss is involved in >>>>>>>>>> infinite recursion within the algorithm of Hss. Dan and Dah >>>>>>>>>> are not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results >>>>>>>>>> in nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result. >>>>>>>>>> Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation >>>>>>>>>> ends normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation >>>>>>>>>> of Hah returns to the simulation of Dah, which does not end. >>>>>>>>>> So Hss never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of >>>>>>>>>> Hss is not aborted. So, does Han recognize the infinite
recursion? That depends on details not provided by olcott. >>>>>>>>>> Han(Dan,Dan): Han recognizes its own algorithm, aborts and >>>>>>>>>> reports 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of >>>>>>>>>> Hah is not aborted. The simulation of Hah returns with
'halting'. Does Han subsequently recognize that D starts an >>>>>>>>>> infinite loop? That depends on details not provides by olcott. >>>>>>>>>>
Hah(Dss,Dss): Hah is different from Hss, so the simulation of >>>>>>>>>> Hss is not aborted. So, does Hah recognize the infinite
recursion? That depends on details not provided by olcott. >>>>>>>>>> Hah(Dan,Dan): Hah is different from Han, so the simulation of >>>>>>>>>> Han is not aborted. The simulation of Ha returns with
'non-halting'. The simulation of D will end normally and Hah >>>>>>>>>> will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and
reports 'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that >>>>>>>>>> the three most important ones Hss(Dss,Dss), Han(Dan,Dan) and >>>>>>>>>> Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using >>>>>>>>>> the same names D and H for different things? That would make >>>>>>>>>> the discussion more transparent. And maybe olcott can tell >>>>>>>>>> which case is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or >>>>>>>>>> Hah(Dah,Dah), or one of the other combinations. Are we talking >>>>>>>>>> about an aborting, or a non-aborting decider? I ask this,
because sentence fragments like 'keeps looping unless
aborted', suggests that it is not always aborted, so it is not >>>>>>>>>> clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be >>>>>>>>> correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct
simulation of
input D that itself would never stop running unless it aborts its >>>>>>>>> simulation of D is necessarily correct to report that *D DOES >>>>>>>>> NOT HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception. >>>>>>> One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not
abort, or one of the aborting ones?
*The infinite set of every H that matches this template*
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to abort this simulation and
report that *D DOES NOT HALT*
Please, make up your mind. Does it never stop running, or does it
abort? It cannot do both.
It correctly determines that its input never halts thus providing
H the criteria it needs to abort its simulation and force it to
terminate abnormally, thus still never halt.
A Turing machine description simulated by a UTM that has
been adapted to become a simulating termination analyzer
can be terminated abnormally.
On 1/29/2024 4:40 PM, immibis wrote:
On 1/29/24 23:13, olcott wrote:
On 1/29/2024 4:09 PM, immibis wrote:Turing machines cannot terminate abnormally.
Turing machines cannot terminate abnormally.
A Turing machine description simulated by a UTM that has
been adapted to become a simulating termination analyzer
can be terminated abnormally.
Turing machine descriptions cannot do ANYTHING because they are just
descriptions.
Just like a BASIC program (that is only static text) becomes
an executing process when interpreted in a BASIC interpreter
so does a TMD when simulated by a UTM.
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote:
On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that >>>>>>>>>>>>>>>>>>>>> the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to write >>>>>>>>>>>>>>>>>>>> a program that reports whether the direct execution >>>>>>>>>>>>>>>>>>>> of its input would halt?
When-so-ever an input calls its own termination analyzer >>>>>>>>>>>>>>>>>>> in recursive simulation then H is not allowed to report >>>>>>>>>>>>>>>>>>> on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D >>>>>>>>>>>>>>>>>>> to prevent its own infinite execution is necessarily >>>>>>>>>>>>>>>>>>> correct to reject D as non-halting.
Do you believe it's impossible or possible to write a >>>>>>>>>>>>>>>>>> program that reports whether the direct execution of >>>>>>>>>>>>>>>>>> its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H
actually does.
When-so-ever any simulating termination analyzer H must abort the >>>>>>>>> simulation of its input D to prevent its own infinite execution >>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and >>>>>>>> thus into the program of D, so when you "alter" H to not abort >>>>>>>> to show this, D doesn't change and still refers to the H that
did abort.
So you are claiming that you just don't understand that every H that >>>>>>> can possibly exist must abort its simulated D because this is simply >>>>>>> over your head because you are not very smart?
just one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring >>>>> every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the
H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all the
same name.
Just as he uses the same name for different halt deciders, some of
which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can imagine
three candidates:
Hss: A simple simulating halt decider, which does not abort. It is
clear it can report only about programs which terminate normally.In
this case it returns 'halting'. It cannot return 'non-halting' in a
finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of this
discussion, we ignore that it very improbable that Han will be
possible to recognize all variations of the algorithm, because we
stick for the moment to the template mentioned above. Similarly it
will not be easy to detect always that the program does the opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite recursion,
not Han.
Hah: A simulating halt decider, similar to Han, but when it recognizes
that the same algorithm is used to do the opposite, it aborts and
returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite recursion,
not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'. Because,
for Hss 'keeps looping' is sufficient, whereas for Han and Hah 'does
not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide on a
template, because different instantiations of a template can do
different things. Therefore, from these three candidates the template
can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss does
not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with 'unless',
because it is clear that only Dss is involved in infinite recursion
within the algorithm of Hss. Dan and Dah are not, because Han and Hah
are not.
Three programs and three candidate halt deciders. That results in nine
combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of Hah
returns to the simulation of Dah, which does not end. So Hss never
returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss is
not aborted. So, does Han recognize the infinite recursion? That
depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports
'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah is
not aborted. The simulation of Hah returns with 'halting'. Does Han
subsequently recognize that D starts an infinite loop? That depends on
details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss is
not aborted. So, does Hah recognize the infinite recursion? That
depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han is
not aborted. The simulation of Ha returns with 'non-halting'. The
simulation of D will end normally and Hah will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are definitely
able to report a correct status. we also see that the three most
important ones Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
return the correct status.
May I suggest that we stick to these names, instead of using the same
names D and H for different things? That would make the discussion
more transparent. And maybe olcott can tell which case is in
discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of the
other combinations. Are we talking about an aborting, or a
non-aborting decider? I ask this, because sentence fragments like
'keeps looping unless aborted', suggests that it is not always
aborted, so it is not clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 9:30 AM, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote >>>>>>>> just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>> When-so-ever any simulating termination analyzer H must abort >>>>>>>>>>> the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote:
On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote:
On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
Three PhD computer science professors agree that >>>>>>>>>>>>>>>>>>>>>>> the haltinghttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>> unsatisfiable
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input >>>>>>>>>>>>>>>>>>>>> D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to write >>>>>>>>>>>>>>>>>>>> a program that reports whether the direct execution >>>>>>>>>>>>>>>>>>>> of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>
D does not specify infinite recursion to H1.
D specifies what ever recursion that H generates.
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite execution >>>>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and >>>>>>>>>> thus into the program of D, so when you "alter" H to not abort >>>>>>>>>> to show this, D doesn't change and still refers to the H that >>>>>>>>>> did abort.
So you are claiming that you just don't understand that every H >>>>>>>>> that
can possibly exist must abort its simulated D because this is >>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for
the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all
the same name.
Just as he uses the same name for different halt deciders, some of
which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can imagine
three candidates:
Hss: A simple simulating halt decider, which does not abort. It is
clear it can report only about programs which terminate normally.In
this case it returns 'halting'. It cannot return 'non-halting' in a
finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of this
discussion, we ignore that it very improbable that Han will be
possible to recognize all variations of the algorithm, because we
stick for the moment to the template mentioned above. Similarly it
will not be easy to detect always that the program does the opposite.) >>>>
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'. Because,
for Hss 'keeps looping' is sufficient, whereas for Han and Hah 'does
not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide on
a template, because different instantiations of a template can do
different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with 'unless',
because it is clear that only Dss is involved in infinite recursion
within the algorithm of Hss. Dan and Dah are not, because Han and
Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss is
not aborted. So, does Han recognize the infinite recursion? That
depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports
'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah is
not aborted. The simulation of Hah returns with 'halting'. Does Han
subsequently recognize that D starts an infinite loop? That depends
on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss is
not aborted. So, does Hah recognize the infinite recursion? That
depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han is
not aborted. The simulation of Ha returns with 'non-halting'. The
simulation of D will end normally and Hah will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are definitely
able to report a correct status. we also see that the three most
important ones Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case is
in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of
the other combinations. Are we talking about an aborting, or a
non-aborting decider? I ask this, because sentence fragments like
'keeps looping unless aborted', suggests that it is not always
aborted, so it is not clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
Except that your statement is based on an illogical premise, that a
SPECIFIC GIVEN Pro could have both aborted its simulation and not.
*It does not say anything like that, try reading it many more times*
*It does not say anything like that, try reading it many more times*
*It does not say anything like that, try reading it many more times*
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 1:19 PM, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
Except that you aren't ALLOWED to change definitions and stay in the
same Theory. If you try, you have just thrusted your self into a
DIFFERENT field of PO-Compuations and your POOP problem.
Halt deciders have always been required to compute the mapping
from their finite strong input to their own accept or reject
state on the basis of *THE BEHAVIOR THAT THIS FINITE STRING SPECIFIES*
On 1/29/2024 9:00 PM, Richard Damon wrote:
On 1/29/24 9:26 PM, olcott wrote:
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 9:30 AM, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
Except that your statement is based on an illogical premise, that a
SPECIFIC GIVEN Pro could have both aborted its simulation and not.
*It does not say anything like that, try reading it many more times*
*It does not say anything like that, try reading it many more times*
*It does not say anything like that, try reading it many more times*
SHOW THE LINE WHERE HE SAYS WHAT YOU CLAIM
FAILURE TO DO SO IS JUST ANOTHER ADMISSION THAT YOU ARE A LIAR, LIKE
YOU HAVE ADMITTED MANY TIMES IN THE PAST.
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
One way is correct and all alternative ways are incorrect.
Op 29.jan.2024 om 20:24 schreef olcott:
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote just
On 1/27/24 6:39 PM, olcott wrote:So you are claiming that you just don't understand that every H that
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
D specifies infinite recursion to H.On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree that the halting
problem has been intentionally defined to be unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct execution of D(D).
Do you believe it's impossible or possible to write a program that
reports whether the direct execution of its input would halt?
When-so-ever an input calls its own termination analyzer
in recursive simulation then H is not allowed to report
on different behavior than the behavior that it sees. >>>>>>>>>>>>>>>>>>>>>>>>
Every H that must abort its simulation of any input D to prevent its
own infinite execution is necessarily correct to reject D as
non-halting.
Do you believe it's impossible or possible to write a program that
reports whether the direct execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual property
of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>>> its simulation of D so that H itself can halt. >>>>>>>>>>>>>>>>
D only specifies as much recursive simulation to H as H actually does.
simulation of its input D to prevent its own infinite execution >>>>>>>>>>>>>> it is always necessarily correct for H to reject this input as >>>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show this,
D doesn't change and still refers to the H that did abort. >>>>>>>>>>>>
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the H >>>>>>>>> that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different instantiations >>>>>>> can be made of a template and olcott gives them all the same name. >>>>>>> Just as he uses the same name for different halt deciders, some of >>>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders? >>>>>>> Here we limit ourselves to simulating halt deciders. We can imagine >>>>>>> three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>>> clear it can report only about programs which terminate normally.In >>>>>>> this case it returns 'halting'. It cannot return 'non-halting' in a >>>>>>> finite time.
Han: A simulating halt decider that, when it recognizes that the >>>>>>> program uses the same algorithm that is used in Han to do the opposite, >>>>>>> it aborts and returns 'non-halting'. (For the sake of this discussion, >>>>>>> we ignore that it very improbable that Han will be possible to
recognize all variations of the algorithm, because we stick for the >>>>>>> moment to the template mentioned above. Similarly it will not be easy >>>>>>> to detect always that the program does the opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite recursion, >>>>>>> not Han.
Hah: A simulating halt decider, similar to Han, but when it recognizes >>>>>>> that the same algorithm is used to do the opposite, it aborts and >>>>>>> returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite recursion, >>>>>>> not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'. Because, >>>>>>> for Hss 'keeps looping' is sufficient, whereas for Han and Hah 'does >>>>>>> not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide on a >>>>>>> template, because different instantiations of a template can do
different things. Therefore, from these three candidates the template >>>>>>> can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss does >>>>>>> not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with 'unless', >>>>>>> because it is clear that only Dss is involved in infinite recursion >>>>>>> within the algorithm of Hss. Dan and Dah are not, because Han and Hah >>>>>>> are not.
Three programs and three candidate halt deciders. That results in nine >>>>>>> combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of Hah >>>>>>> returns to the simulation of Dah, which does not end. So Hss never >>>>>>> returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss is >>>>>>> not aborted. So, does Han recognize the infinite recursion? That >>>>>>> depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah is >>>>>>> not aborted. The simulation of Hah returns with 'halting'. Does Han >>>>>>> subsequently recognize that D starts an infinite loop? That depends on >>>>>>> details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss is >>>>>>> not aborted. So, does Hah recognize the infinite recursion? That >>>>>>> depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han is >>>>>>> not aborted. The simulation of Ha returns with 'non-halting'. The >>>>>>> simulation of D will end normally and Hah will report 'halting'. >>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports 'halting'.
From these nine combinations we see that only a few are definitely >>>>>>> able to report a correct status. we also see that the three most >>>>>>> important ones Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not >>>>>>> return the correct status.
May I suggest that we stick to these names, instead of using the same >>>>>>> names D and H for different things? That would make the discussion more >>>>>>> transparent. And maybe olcott can tell which case is in discussion, >>>>>>> Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of the other
combinations. Are we talking about an aborting, or a non-aborting >>>>>>> decider? I ask this, because sentence fragments like 'keeps looping >>>>>>> unless aborted', suggests that it is not always aborted, so it is not >>>>>>> clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT* >>>>>>
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not abort, or
one of the aborting ones?
*The infinite set of every H that matches this template*
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to abort this simulation and
report that *D DOES NOT HALT*
On 10/13/2022 11:46 AM, olcott wrote:
MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.
It seems olcott is unable to answer whether his halting decider aborts
or not. Do we really have to believe that the execution trace he showed
us, is from an infinite set of deciders?
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four (4) times.
There is only one single relevant detail and changing the subject away
from this is off topic thus must be ignored.
On 1/29/2024 10:02 PM, Richard Damon wrote:
On 1/29/24 10:54 PM, olcott wrote:
On 1/29/2024 9:00 PM, Richard Damon wrote:
On 1/29/24 9:26 PM, olcott wrote:
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 9:30 AM, olcott wrote:*It does not say anything like that, try reading it many more times* >>>>> *It does not say anything like that, try reading it many more times* >>>>> *It does not say anything like that, try reading it many more times* >>>>>
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:The Peter Linz proof uses a program template simultaneously >>>>>>>>>>> referring
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>>>> wrote just one H, not every one that could possibly exist. >>>>>>>>>>>
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>>>> that the halting
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the >>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed >>>>>>>>>>>>>>>>>>>>>>>>> to report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution >>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H? >>>>>>>>>>>>>>>>>>>>> No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as >>>>>>>>>>>>>>>>>>>> the actual property of Halting is independent of who >>>>>>>>>>>>>>>>>>>> you ask.
D specifies infinite recursion to H.
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt. >>>>>>>>>>>>>>>>>
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this >>>>>>>>>>>>>>> input as
non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>>>> and thus into the program of D, so when you "alter" H to >>>>>>>>>>>>>> not abort to show this, D doesn't change and still refers >>>>>>>>>>>>>> to the H that did abort.
So you are claiming that you just don't understand that >>>>>>>>>>>>> every H that
can possibly exist must abort its simulated D because this >>>>>>>>>>>>> is simply
over your head because you are not very smart?
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof >>>>>>>>>> for the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them >>>>>>>> all the same name.
Just as he uses the same name for different halt deciders, some >>>>>>>> of which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders? >>>>>>>> Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It >>>>>>>> is clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the >>>>>>>> program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of >>>>>>>> this discussion, we ignore that it very improbable that Han will >>>>>>>> be possible to recognize all variations of the algorithm,
because we stick for the moment to the template mentioned above. >>>>>>>> Similarly it will not be easy to detect always that the program >>>>>>>> does the opposite.)
It is clear that Han is wrong if it assumes that Han will do an >>>>>>>> infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, >>>>>>>> it aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an >>>>>>>> infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated >>>>>>>> sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han >>>>>>>> and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide >>>>>>>> on a template, because different instantiations of a template
can do different things. Therefore, from these three candidates >>>>>>>> the template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because
Hss does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt. >>>>>>>>
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are >>>>>>>> not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results >>>>>>>> in nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends >>>>>>>> normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation >>>>>>>> of Hah returns to the simulation of Dah, which does not end. So >>>>>>>> Hss never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of
Hss is not aborted. So, does Han recognize the infinite
recursion? That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and
reports 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of
Hah is not aborted. The simulation of Hah returns with
'halting'. Does Han subsequently recognize that D starts an
infinite loop? That depends on details not provides by olcott. >>>>>>>>
Hah(Dss,Dss): Hah is different from Hss, so the simulation of
Hss is not aborted. So, does Hah recognize the infinite
recursion? That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of
Han is not aborted. The simulation of Ha returns with
'non-halting'. The simulation of D will end normally and Hah
will report 'halting'.
Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and
reports 'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the >>>>>>>> three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the >>>>>>>> same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which
case is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or
Hah(Dah,Dah), or one of the other combinations. Are we talking >>>>>>>> about an aborting, or a non-aborting decider? I ask this,
because sentence fragments like 'keeps looping unless aborted', >>>>>>>> suggests that it is not always aborted, so it is not clear
whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be
correctly encoded is the current way that H is encoded.
Every H that correctly determines in N steps of correct
simulation of
input D that itself would never stop running unless it aborts its >>>>>>> simulation of D is necessarily correct to report that *D DOES NOT >>>>>>> HALT*
Except that your statement is based on an illogical premise, that
a SPECIFIC GIVEN Pro could have both aborted its simulation and not. >>>>>
SHOW THE LINE WHERE HE SAYS WHAT YOU CLAIM
FAILURE TO DO SO IS JUST ANOTHER ADMISSION THAT YOU ARE A LIAR, LIKE
YOU HAVE ADMITTED MANY TIMES IN THE PAST.
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
There is no H that aborts its simulation and also not abort its
simulation.
I can't believe that an MIT grad can't understand words.
Thus conclude that you do understand these words.
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 1:19 PM, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
Except that you aren't ALLOWED to change definitions and stay in the
same Theory. If you try, you have just thrusted your self into a
DIFFERENT field of PO-Compuations and your POOP problem.
Halt deciders have always been required to compute the mapping
from their finite strong input to their own accept or reject
state on the basis of *THE BEHAVIOR THAT THIS FINITE STRING SPECIFIES*
On 1/29/2024 9:00 PM, Richard Damon wrote:
On 1/29/24 9:26 PM, olcott wrote:
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 9:30 AM, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:My whole purpose is to show the only possible way that H can be
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You >>>>>>>>>> wrote just one H, not every one that could possibly exist.
On 1/27/24 6:39 PM, olcott wrote:
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must >>>>>>>>>>>>> abort the
On 1/27/2024 4:52 PM, Richard Damon wrote:
On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote:
On 1/27/24 4:27 PM, olcott wrote:D specifies infinite recursion to H.
On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree >>>>>>>>>>>>>>>>>>>>>>>>> that the halting
problem has been intentionally defined to be >>>>>>>>>>>>>>>>>>>>>>>>> unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct >>>>>>>>>>>>>>>>>>>>>>>>> execution of D(D).
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt? >>>>>>>>>>>>>>>>>>>>>>>>
When-so-ever an input calls its own termination >>>>>>>>>>>>>>>>>>>>>>> analyzer
in recursive simulation then H is not allowed to >>>>>>>>>>>>>>>>>>>>>>> report
on different behavior than the behavior that it >>>>>>>>>>>>>>>>>>>>>>> sees.
Every H that must abort its simulation of any >>>>>>>>>>>>>>>>>>>>>>> input D to prevent its own infinite execution is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as non-halting. >>>>>>>>>>>>>>>>>>>>>>>
Do you believe it's impossible or possible to >>>>>>>>>>>>>>>>>>>>>> write a program that reports whether the direct >>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question >>>>>>>>>>>>>>>>>>>> actually asked?
Does D specify halting behavior to H?
No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the >>>>>>>>>>>>>>>>>> actual property of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
D only specifies as much recursive simulation to H as H >>>>>>>>>>>>>> actually does.
simulation of its input D to prevent its own infinite >>>>>>>>>>>>> execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, >>>>>>>>>>>> and thus into the program of D, so when you "alter" H to not >>>>>>>>>>>> abort to show this, D doesn't change and still refers to the >>>>>>>>>>>> H that did abort.
So you are claiming that you just don't understand that every >>>>>>>>>>> H that
can possibly exist must abort its simulated D because this is >>>>>>>>>>> simply
over your head because you are not very smart?
The Peter Linz proof uses a program template simultaneously
referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for >>>>>>>> the H that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different
instantiations can be made of a template and olcott gives them all >>>>>> the same name.
Just as he uses the same name for different halt deciders, some of >>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders?
Here we limit ourselves to simulating halt deciders. We can
imagine three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>> clear it can report only about programs which terminate
normally.In this case it returns 'halting'. It cannot return
'non-halting' in a finite time.
Han: A simulating halt decider that, when it recognizes that the
program uses the same algorithm that is used in Han to do the
opposite, it aborts and returns 'non-halting'. (For the sake of
this discussion, we ignore that it very improbable that Han will
be possible to recognize all variations of the algorithm, because
we stick for the moment to the template mentioned above. Similarly >>>>>> it will not be easy to detect always that the program does the
opposite.)
It is clear that Han is wrong if it assumes that Han will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Han.
Hah: A simulating halt decider, similar to Han, but when it
recognizes that the same algorithm is used to do the opposite, it
aborts and returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an
infinite recursion, because it is Hss that does an infinite
recursion, not Hah.
Using these names it is no longer needed to use overcomplicated
sentence fragments, such as 'keeps looping unless aborted'.
Because, for Hss 'keeps looping' is sufficient, whereas for Han
and Hah 'does not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide
on a template, because different instantiations of a template can
do different things. Therefore, from these three candidates the
template can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss
does not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt.
Again, we do no longer need overcomplicated sentences with
'unless', because it is clear that only Dss is involved in
infinite recursion within the algorithm of Hss. Dan and Dah are
not, because Han and Hah are not.
Three programs and three candidate halt deciders. That results in
nine combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends
normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of
Hah returns to the simulation of Dah, which does not end. So Hss
never returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss
is not aborted. So, does Han recognize the infinite recursion?
That depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah
is not aborted. The simulation of Hah returns with 'halting'. Does >>>>>> Han subsequently recognize that D starts an infinite loop? That
depends on details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss
is not aborted. So, does Hah recognize the infinite recursion?
That depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han
is not aborted. The simulation of Ha returns with 'non-halting'.
The simulation of D will end normally and Hah will report 'halting'. >>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports
'halting'.
From these nine combinations we see that only a few are
definitely able to report a correct status. we also see that the
three most important ones Hss(Dss,Dss), Han(Dan,Dan) and
Hah(Dah,Dah) do not return the correct status.
May I suggest that we stick to these names, instead of using the
same names D and H for different things? That would make the
discussion more transparent. And maybe olcott can tell which case
is in discussion, Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or
one of the other combinations. Are we talking about an aborting,
or a non-aborting decider? I ask this, because sentence fragments
like 'keeps looping unless aborted', suggests that it is not
always aborted, so it is not clear whether Hss, Han, or Han is meant. >>>>>
correctly encoded is the current way that H is encoded.
Every H that correctly determines in N steps of correct simulation of >>>>> input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT
HALT*
Except that your statement is based on an illogical premise, that a
SPECIFIC GIVEN Pro could have both aborted its simulation and not.
*It does not say anything like that, try reading it many more times*
*It does not say anything like that, try reading it many more times*
*It does not say anything like that, try reading it many more times*
SHOW THE LINE WHERE HE SAYS WHAT YOU CLAIM
FAILURE TO DO SO IS JUST ANOTHER ADMISSION THAT YOU ARE A LIAR, LIKE
YOU HAVE ADMITTED MANY TIMES IN THE PAST.
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to report that *D DOES NOT HALT*
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
An aborted simulation of D DOES NOT COUNT AS D HALTING!!!
On 1/30/2024 5:37 AM, Mikko wrote:
On 2024-01-29 22:18:11 +0000, olcott said:
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four (4)
times.
There is only one single relevant detail and changing the subject away
from this is off topic thus must be ignored.
Be specific: the relevant detail is that H is a halt decider
only if H(D,D) <-> D(D) halts.
It is a verified fact that the x86 machine code of D specifies
recursive simulation to H.
On 1/30/2024 5:37 AM, Mikko wrote:
On 2024-01-29 22:18:11 +0000, olcott said:
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four (4)
times.
There is only one single relevant detail and changing the subject away
from this is off topic thus must be ignored.
Be specific: the relevant detail is that H is a halt decider
only if H(D,D) <-> D(D) halts.
It is a verified fact that the x86 machine code of D specifies
recursive simulation to H.
*The tautology proves that the H on lines 668-691 is correct* https://github.com/plolcott/x86utm/blob/master/Halt7.c
Every correct H correctly aborts its corresponding D and correctly
rejects D as non-halting.
On 1/30/2024 5:37 AM, Mikko wrote:
On 2024-01-29 22:18:11 +0000, olcott said:
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:There is only one single relevant detail and changing the subject away
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four (4) times. >>>
from this is off topic thus must be ignored.
Be specific: the relevant detail is that H is a halt decider
only if H(D,D) <-> D(D) halts.
It is a verified fact that the x86 machine code of D specifies
recursive simulation to H.
On 1/30/2024 5:30 AM, Mikko wrote:
On 2024-01-29 20:00:24 +0000, Fred. Zwarts said:
Op 29.jan.2024 om 20:24 schreef olcott:
On 1/29/2024 1:19 PM, Fred. Zwarts wrote:
Op 29.jan.2024 om 19:19 schreef olcott:
On 1/29/2024 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
Op 28.jan.2024 om 16:28 schreef olcott:
On 1/28/2024 6:12 AM, immibis wrote:
On 1/28/24 01:36, olcott wrote:
On 1/27/2024 6:33 PM, immibis wrote:
On 1/28/24 01:32, olcott wrote:
On 1/27/2024 6:09 PM, Richard Damon wrote:Who's talking about every H that could possibly exist? You wrote just
On 1/27/24 6:39 PM, olcott wrote:So you are claiming that you just don't understand that every H that
On 1/27/2024 5:34 PM, Richard Damon wrote:
On 1/27/24 5:58 PM, olcott wrote:*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS* >>>>>>>>>>>>>>>> When-so-ever any simulating termination analyzer H must abort the
On 1/27/2024 4:52 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
On 1/27/2024 4:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
D specifies infinite recursion to H.On 1/27/2024 3:03 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors agree that the halting
problem has been intentionally defined to be unsatisfiablehttps://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
when H is required to report on the direct execution of D(D).
Do you believe it's impossible or possible to write a program that
reports whether the direct execution of its input would halt?
When-so-ever an input calls its own termination analyzer
in recursive simulation then H is not allowed to report
on different behavior than the behavior that it sees.
Every H that must abort its simulation of any input D to prevent its
own infinite execution is necessarily correct to reject D as
non-halting.
Do you believe it's impossible or possible to write a program that
reports whether the direct execution of its input would halt?
*It in incorrect for H to do this in some cases* >>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
Why would it be incorrect to answer the question actually asked?
Does D specify halting behavior to H? >>>>>>>>>>>>>>>>>>>>>> No it does not.
Yes, it specifies Halting Behavior to EVERYONE, as the actual property
of Halting is independent of who you ask. >>>>>>>>>>>>>>>>>>>>
D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>>
D specifies what ever recursion that H generates. >>>>>>>>>>>>>>>>>>>
D specifies recursive simulation to H forcing H to abort >>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt. >>>>>>>>>>>>>>>>>>
D only specifies as much recursive simulation to H as H actually does.
simulation of its input D to prevent its own infinite execution
it is always necessarily correct for H to reject this input as >>>>>>>>>>>>>>>> non-halting.
And the decision to abort was encoded in the program of H, and thus
into the program of D, so when you "alter" H to not abort to show this,
D doesn't change and still refers to the H that did abort. >>>>>>>>>>>>>>
can possibly exist must abort its simulated D because this is simply
over your head because you are not very smart?
one H, not every one that could possibly exist.
The Peter Linz proof uses a program template simultaneously referring
every H that can possibly exist.
The Peter Linz proof template tells you how to make a proof for the H
that you have.
That is why I apply my proof of H/D to the Linz proof
in my paper. Richard just doesn't seem to get the idea
of a program template. He does not understand that
analysis can be simultaneously applied to an infinite
set of programs.
One of the problems in this discussion is that different instantiations
can be made of a template and olcott gives them all the same name. >>>>>>>>> Just as he uses the same name for different halt deciders, some of >>>>>>>>> which abort and others do not abort.
May I suggest a naming for the different candidate halt decoders? >>>>>>>>> Here we limit ourselves to simulating halt deciders. We can imagine >>>>>>>>> three candidates:
Hss: A simple simulating halt decider, which does not abort. It is >>>>>>>>> clear it can report only about programs which terminate normally.In >>>>>>>>> this case it returns 'halting'. It cannot return 'non-halting' in a >>>>>>>>> finite time.
Han: A simulating halt decider that, when it recognizes that the >>>>>>>>> program uses the same algorithm that is used in Han to do the opposite,
it aborts and returns 'non-halting'. (For the sake of this discussion,
we ignore that it very improbable that Han will be possible to >>>>>>>>> recognize all variations of the algorithm, because we stick for the >>>>>>>>> moment to the template mentioned above. Similarly it will not be easy >>>>>>>>> to detect always that the program does the opposite.)
It is clear that Han is wrong if it assumes that Han will do an >>>>>>>>> infinite recursion, because it is Hss that does an infinite recursion,
not Han.
Hah: A simulating halt decider, similar to Han, but when it recognizes
that the same algorithm is used to do the opposite, it aborts and >>>>>>>>> returns 'halting'.
It is clear that Hah is wrong if it assumes that Hah will do an >>>>>>>>> infinite recursion, because it is Hss that does an infinite recursion,
not Hah.
Using these names it is no longer needed to use overcomplicated >>>>>>>>> sentence fragments, such as 'keeps looping unless aborted'. Because, >>>>>>>>> for Hss 'keeps looping' is sufficient, whereas for Han and Hah 'does >>>>>>>>> not loop, because aborted' is more clear.
A halting decider needs a program to decide on. It cannot decide on a >>>>>>>>> template, because different instantiations of a template can do >>>>>>>>> different things. Therefore, from these three candidates the template >>>>>>>>> can be used to create three programs:
Dss: based on Hss. It is clear that it does not halt, because Hss does
not halt.
Dan: based on Han. Han returns 'non-halting', so Dan halts.
Dah: based on Hah. Han returns 'halting', so Dan does not halt. >>>>>>>>>
Again, we do no longer need overcomplicated sentences with 'unless', >>>>>>>>> because it is clear that only Dss is involved in infinite recursion >>>>>>>>> within the algorithm of Hss. Dan and Dah are not, because Han and Hah >>>>>>>>> are not.
Three programs and three candidate halt deciders. That results in nine
combinations:
Hss(Dss,Dss): Hss does not halt and never returns a result.
Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation ends >>>>>>>>> normally and Hss reports 'Halting'.
Hss(Dah,Dah): Hss simulates Dah, including Hah. The simulation of Hah >>>>>>>>> returns to the simulation of Dah, which does not end. So Hss never >>>>>>>>> returns a result.
Han(Dss,Dss): Han is different from Hss, so the simulation of Hss is >>>>>>>>> not aborted. So, does Han recognize the infinite recursion? That >>>>>>>>> depends on details not provided by olcott.
Han(Dan,Dan): Han recognizes its own algorithm, aborts and reports >>>>>>>>> 'non-halting'.
Han(Dah,Dah): Han is different from Hah, so the simulation of Hah is >>>>>>>>> not aborted. The simulation of Hah returns with 'halting'. Does Han >>>>>>>>> subsequently recognize that D starts an infinite loop? That depends on
details not provides by olcott.
Hah(Dss,Dss): Hah is different from Hss, so the simulation of Hss is >>>>>>>>> not aborted. So, does Hah recognize the infinite recursion? That >>>>>>>>> depends on details not provided by olcott.
Hah(Dan,Dan): Hah is different from Han, so the simulation of Han is >>>>>>>>> not aborted. The simulation of Ha returns with 'non-halting'. The >>>>>>>>> simulation of D will end normally and Hah will report 'halting'. >>>>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and reports 'halting'.
From these nine combinations we see that only a few are definitely >>>>>>>>> able to report a correct status. we also see that the three most >>>>>>>>> important ones Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not >>>>>>>>> return the correct status.
May I suggest that we stick to these names, instead of using the same >>>>>>>>> names D and H for different things? That would make the discussion more
transparent. And maybe olcott can tell which case is in discussion, >>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of the other >>>>>>>>> combinations. Are we talking about an aborting, or a non-aborting >>>>>>>>> decider? I ask this, because sentence fragments like 'keeps looping >>>>>>>>> unless aborted', suggests that it is not always aborted, so it is not >>>>>>>>> clear whether Hss, Han, or Han is meant.
My whole purpose is to show the only possible way that H can be >>>>>>>> correctly encoded is the current way that H is encoded.
And which way is that? Is it Hss, Han, Hap or something else?
Every H that correctly determines in N steps of correct simulation of >>>>>>>> input D that itself would never stop running unless it aborts its >>>>>>>> simulation of D is necessarily correct to report that *D DOES NOT HALT*
You aren't listening.
I am listening and I am overriding and superseding misconception.
One way is correct and all alternative ways are incorrect.
And which way is it? Hss, HAn, or HAh? The one that does not abort, or >>>>> one of the aborting ones?
*The infinite set of every H that matches this template*
Every H that correctly determines in N steps of correct simulation of
input D that itself would never stop running unless it aborts its
simulation of D is necessarily correct to abort this simulation and
report that *D DOES NOT HALT*
On 10/13/2022 11:46 AM, olcott wrote:
MIT Professor Michael Sipser has agreed that the following
verbatim paragraph is correct ...
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then H can abort its simulation
of D and correctly report that D specifies a non-halting
sequence of configurations.
It seems olcott is unable to answer whether his halting decider aborts
or not. Do we really have to believe that the execution trace he showed
us, is from an infinite set of deciders?
He only shows partial traces. Infinitely many traces contaion those shown
parts but differ in other parts.
On 1/30/2024 5:26 AM, Mikko wrote:
On 2024-01-29 18:19:50 +0000, olcott said:
One way is correct and all alternative ways are incorrect.
That is one misconception you should override.
*The tautology proves that the H on lines 668-691 is correct* https://github.com/plolcott/x86utm/blob/master/Halt7.c
Every correct H correctly aborts its corresponding D and correctly
rejects D as non-halting.
On 1/31/2024 2:24 AM, Mikko wrote:
On 2024-01-30 15:03:10 +0000, olcott said:
On 1/30/2024 5:37 AM, Mikko wrote:
On 2024-01-29 22:18:11 +0000, olcott said:
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception. >>>>>>> One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four
(4) times.
There is only one single relevant detail and changing the subject away >>>>> from this is off topic thus must be ignored.
Be specific: the relevant detail is that H is a halt decider
only if H(D,D) <-> D(D) halts.
It is a verified fact that the x86 machine code of D specifies
recursive simulation to H.
From the meanings of the words follow (so you may call it self-evident)
that if H(D,D) specifes an infinite recursion for any D then
H is not a halt decider (nor any other decider, either).
It is a verified fact that input D specifies recursive
simulation to every simulating termination analyzer H.
On 1/31/2024 2:24 AM, Mikko wrote:
On 2024-01-30 15:03:10 +0000, olcott said:
On 1/30/2024 5:37 AM, Mikko wrote:
On 2024-01-29 22:18:11 +0000, olcott said:
On 1/29/2024 4:11 PM, immibis wrote:
On 1/29/24 19:19, olcott wrote:
On 1/29/2024 8:47 AM, immibis wrote:
You aren't listening.
I am listening and I am overriding and superseding misconception. >>>>>>> One way is correct and all alternative ways are incorrect.
You have now ignored my formulation of the halting problem four
(4) times.
There is only one single relevant detail and changing the subject away >>>>> from this is off topic thus must be ignored.
Be specific: the relevant detail is that H is a halt decider
only if H(D,D) <-> D(D) halts.
It is a verified fact that the x86 machine code of D specifies
recursive simulation to H.
From the meanings of the words follow (so you may call it self-evident)
that if H(D,D) specifes an infinite recursion for any D then
H is not a halt decider (nor any other decider, either).
It is a verified fact that input D specifies recursive
simulation to every simulating termination analyzer H.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 307 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 45:35:07 |
| Calls: | 6,910 |
| Files: | 12,377 |
| Messages: | 5,429,451 |