On 1/31/2024 11:12 AM, Mikko wrote:
On 2024-01-31 14:52:29 +0000, olcott said:
On 1/31/2024 2:30 AM, Mikko wrote:
On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
Op 30.jan.2024 om 15:52 schreef olcott:
On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
Op 30.jan.2024 om 06:05 schreef olcott:
On 1/29/2024 9:01 PM, Richard Damon wrote:
On 1/29/24 9:30 PM, olcott wrote:
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:And which way is that? Is it Hss, Han, Hap or something else? >>>>>>>>>>>>>
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: >>>>>>>>>>>>>>>>>>>>> On 1/27/24 6:39 PM, olcott wrote:Who's talking about every H that could possibly exist? You wrote just
On 1/27/2024 5:34 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:58 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> 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
*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*D specifies infinite recursion to H. >>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>>>>>>>>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 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. >>>>>>>>>>>>>>>>>>
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*
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*
Strings themselves do not have "Behavior"
In computability theory, Rice's theorem states that all non-trivial >>>>>>>> semantic properties of programs are undecidable. A semantic property is
one *about the program's behavior* (for instance, does the program >>>>>>>> terminate for all inputs), unlike a syntactic property (for instance, >>>>>>>> does the program contain an if-then-else statement). A property is >>>>>>>> non-trivial if it is neither true for every program, nor false for >>>>>>>> every program. https://en.wikipedia.org/wiki/Rice%27s_theorem >>>>>>>>>
The the behavior specified by the input is NOT the Halting Behavior of
the Compuation described by the input,
The term "specified" is more precise than "described by". The
latter term allows indirect reference whereas the former one
does not.
D simulated by H such that H executes the x86 machine code that >>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is >>>>>>>> to incorrectly execute the x86 machine code that D specifies.
Which D?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every correct H correctly aborts its corresponding D and correctly >>>>>> rejects D as non-halting.
Olcott keeps hiding the details. Which H is shown here?
If it is the aborting H, which we call Han, then there is no need to >>>>> abort D, because Han aborts itself already. It cannot be at the same >>>>> time Hss, which does not abort. Hss and Han are different deciders with >>>>> different behaviour and therefore, Dss is different from Dan
Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss.
As Olcott uses in his proofs the inferene rule knonw as equivocation
he must restrict his naming conventions.
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted
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 }
Then every simulating termination analyzer H specified by
the above template is correct to abort its simulation of D
and reject D as non-halting.
Nice to see that you agree with my observation.
HOwever, the above template does not specify a simulating rermination
analyzer.
Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.
*PREMISE*
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted:
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 }
*LOGICALLY ENTAILED BY PREMISE*
Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.
Pages 661 to 696 of Halt7.c specify the H that does this https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 2/1/2024 3:54 AM, Mikko wrote:
On 2024-01-31 17:18:32 +0000, olcott said:
On 1/31/2024 11:12 AM, Mikko wrote:
On 2024-01-31 14:52:29 +0000, olcott said:
On 1/31/2024 2:30 AM, Mikko wrote:
On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
Op 30.jan.2024 om 15:52 schreef olcott:As Olcott uses in his proofs the inferene rule knonw as equivocation >>>>>> he must restrict his naming conventions.
On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
Op 30.jan.2024 om 06:05 schreef olcott:
On 1/29/2024 9:01 PM, Richard Damon wrote:
On 1/29/24 9:30 PM, olcott wrote:
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 1:19 PM, olcott wrote: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 8:47 AM, immibis wrote:
On 1/29/24 15:30, olcott wrote:
On 1/29/2024 6:51 AM, Fred. Zwarts wrote:And which way is that? Is it Hss, Han, Hap or something else? >>>>>>>>>>>>>>>
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: >>>>>>>>>>>>>>>>>>>>>>> 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: >>>>>>>>>>>>>>>>>>>>>>>>>> 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 haltingWho's talking about every H that could possibly exist? You wrote just
*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*D specifies infinite recursion to H. >>>>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>>>>>>>>>>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 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. >>>>>>>>>>>>>>>>>>>>
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*
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. >>>>>>>>>>>>
Strings themselves do not have "Behavior"
In computability theory, Rice's theorem states that all non-trivial >>>>>>>>>> semantic properties of programs are undecidable. A semantic property is
one *about the program's behavior* (for instance, does the program >>>>>>>>>> terminate for all inputs), unlike a syntactic property (for instance,
does the program contain an if-then-else statement). A property is >>>>>>>>>> non-trivial if it is neither true for every program, nor false for >>>>>>>>>> every program. https://en.wikipedia.org/wiki/Rice%27s_theorem >>>>>>>>>>>
The the behavior specified by the input is NOT the Halting Behavior of
the Compuation described by the input,
The term "specified" is more precise than "described by". The >>>>>>>>>> latter term allows indirect reference whereas the former one >>>>>>>>>> does not.
D simulated by H such that H executes the x86 machine code that >>>>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is >>>>>>>>>> to incorrectly execute the x86 machine code that D specifies. >>>>>>>>>>
Which D?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every correct H correctly aborts its corresponding D and correctly >>>>>>>> rejects D as non-halting.
Olcott keeps hiding the details. Which H is shown here?
If it is the aborting H, which we call Han, then there is no need to >>>>>>> abort D, because Han aborts itself already. It cannot be at the same >>>>>>> time Hss, which does not abort. Hss and Han are different deciders with >>>>>>> different behaviour and therefore, Dss is different from Dan
Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss. >>>>>>
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted
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 }
Then every simulating termination analyzer H specified by
the above template is correct to abort its simulation of D
and reject D as non-halting.
Nice to see that you agree with my observation.
HOwever, the above template does not specify a simulating rermination
analyzer.
Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.
*PREMISE*
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted:
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 }
*LOGICALLY ENTAILED BY PREMISE*
Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.
Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above template specifies no simulating termination analyzer.
*That is factually incorrect*
Both the template and the code do specify a simulating termination
analyzer.
On 2/1/2024 11:02 AM, Mikko wrote:
On 2024-02-01 14:14:22 +0000, olcott said:
On 2/1/2024 3:54 AM, Mikko wrote:
On 2024-01-31 17:18:32 +0000, olcott said:
On 1/31/2024 11:12 AM, Mikko wrote:
On 2024-01-31 14:52:29 +0000, olcott said:
On 1/31/2024 2:30 AM, Mikko wrote:
On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
Op 30.jan.2024 om 15:52 schreef olcott:As Olcott uses in his proofs the inferene rule knonw as equivocation >>>>>>>> he must restrict his naming conventions.
On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
Op 30.jan.2024 om 06:05 schreef olcott:
On 1/29/2024 9:01 PM, Richard Damon wrote:
On 1/29/24 9:30 PM, olcott wrote:
On 1/29/2024 6:48 PM, Richard Damon wrote:
On 1/29/24 1:19 PM, olcott wrote: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 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:And which way is that? Is it Hss, Han, Hap or something else? >>>>>>>>>>>>>>>>>
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: >>>>>>>>>>>>>>>>>>>>>>>>> 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: >>>>>>>>>>>>>>>>>>>>>>>>>>>> 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
The Peter Linz proof uses a program template simultaneously referringWho's talking about every H that could possibly exist? You wrote just*PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR LIARS*D specifies infinite recursion to H. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>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 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. >>>>>>>>>>>>>>>>>>>>>>
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*
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. >>>>>>>>>>>>>>
Strings themselves do not have "Behavior"
In computability theory, Rice's theorem states that all non-trivial
semantic properties of programs are undecidable. A semantic property is
one *about the program's behavior* (for instance, does the program >>>>>>>>>>>> terminate for all inputs), unlike a syntactic property (for instance,
does the program contain an if-then-else statement). A property is >>>>>>>>>>>> non-trivial if it is neither true for every program, nor false for >>>>>>>>>>>> every program. https://en.wikipedia.org/wiki/Rice%27s_theorem >>>>>>>>>>>>>
The the behavior specified by the input is NOT the Halting Behavior of
the Compuation described by the input,
The term "specified" is more precise than "described by". The >>>>>>>>>>>> latter term allows indirect reference whereas the former one >>>>>>>>>>>> does not.
D simulated by H such that H executes the x86 machine code that >>>>>>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is >>>>>>>>>>>> to incorrectly execute the x86 machine code that D specifies. >>>>>>>>>>>>
Which D?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every correct H correctly aborts its corresponding D and correctly >>>>>>>>>> rejects D as non-halting.
Olcott keeps hiding the details. Which H is shown here?
If it is the aborting H, which we call Han, then there is no need to >>>>>>>>> abort D, because Han aborts itself already. It cannot be at the same >>>>>>>>> time Hss, which does not abort. Hss and Han are different deciders with
different behaviour and therefore, Dss is different from Dan >>>>>>>>>
Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss. >>>>>>>>
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted
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 }
Then every simulating termination analyzer H specified by
the above template is correct to abort its simulation of D
and reject D as non-halting.
Nice to see that you agree with my observation.
HOwever, the above template does not specify a simulating rermination >>>>>> analyzer.
Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.
*PREMISE*
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted:
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 }
*LOGICALLY ENTAILED BY PREMISE*
Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.
Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above template specifies no simulating termination analyzer.
*That is factually incorrect*
Both the template and the code do specify a simulating termination
analyzer.
The template contains neither any of workds "simulating", "termination",
"analyzer", or related words or synonyms nor anything that is or means
any of these.
Mikko
In other words you are expecting C to understand English or did you
simply ignore this quoted from above?
*PREMISE*
When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted:
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 307 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 46:03:56 |
| Calls: | 6,910 |
| Files: | 12,377 |
| Messages: | 5,429,524 |