H is asked the question: Does your input need to be aborted to prevent infinite simulation? H correctly answers yes and aborts the simulation.
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:So, why doesn't that happen when main calls H?
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:Since it is true that unless H aborts its simulation of D that >>>>>>>>>> H itself
On 5/25/2023 9:42 PM, Richard Damon wrote:
On 5/25/23 10:26 PM, olcott wrote:Since it is required to terminate the choice to not abort >>>>>>>>>>>> its simulation
On 5/25/2023 8:56 PM, Richard Damon wrote:
On 5/25/23 9:43 PM, olcott wrote:
On 5/25/2023 8:29 PM, olcott wrote:
On 5/25/2023 7:01 PM, Richard Damon wrote:
On 5/25/23 11:30 AM, olcott wrote:
On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, >>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
Following pseudocode for D:
arbitrarily long int D(int start) {
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) { >>>>>>>>>>>>>>>>>>>>> n = n + 2
}
return n
}
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)?
Why would you care? PO's H returns "does not halt" >>>>>>>>>>>>>>>>>>>> for at least some
halting computations (citations available on >>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest.
PO equivocates over whether he is concerned about >>>>>>>>>>>>>>>>>>>> just the one case used
in the usual proof's construction or the general >>>>>>>>>>>>>>>>>>>> case, but regardless of
what side of that fence he is currently sitting, you >>>>>>>>>>>>>>>>>>>> can't use his H for
anything useful.
How would it know the correct answer? Will it ever >>>>>>>>>>>>>>>>>>>>> return an answer?On some days he will claim that he has never said he >>>>>>>>>>>>>>>>>>>> has a general halt
(Especially, _if_ there is no odd perfect number?) >>>>>>>>>>>>>>>>>>>>
decider, just one that can't be fooled by the "usual >>>>>>>>>>>>>>>>>>>> construction". It
"can't be fooled" because he simply declares that >>>>>>>>>>>>>>>>>>>> H(H^, H^) == false is
the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind and >>>>>>>>>>>>>>>>>>>> claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>> computations "augmented" by
some unspecified set of halting ones.
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question for >>>>>>>>>>>>>>>>>>>> years (literally years),
and he will even say contradictory things days apart >>>>>>>>>>>>>>>>>>>> (again, citations
available on request) so it can take some time to >>>>>>>>>>>>>>>>>>>> clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though P(P) >>>>>>>>>>>>>>>>>>>> halts."
in reply to the question "do you still assert that >>>>>>>>>>>>>>>>>>>> H(P,P) == false is
the 'correct' answer even though P(P) halts?" I >>>>>>>>>>>>>>>>>>>> don't see any point in
carrying on, or at least I see not point in saying >>>>>>>>>>>>>>>>>>>> anything else.
The one weapon we have against cranks is that most >>>>>>>>>>>>>>>>>>>> can't bear to retract
any substantive claim. This is why they are usually >>>>>>>>>>>>>>>>>>>> so evasive about
giving direct answers -- they know they will have to >>>>>>>>>>>>>>>>>>>> stick with them.
But once they have made the mistake of being clear, >>>>>>>>>>>>>>>>>>>> we should pay them
the courtesy of quoting them at every available >>>>>>>>>>>>>>>>>>>> opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a tautology >>>>>>>>>>>>>>>>>>> thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, which is >>>>>>>>>>>>>>>>>> just a form of LYING.
The context does not change the fact that he agreed >>>>>>>>>>>>>>>>> that H does
correctly determine the halt status of D according to >>>>>>>>>>>>>>>>> the Sisper approved criteria.
Because all deciders only compute the mapping *from >>>>>>>>>>>>>>>>>>> their inputs* toSO, what mapping is this supposed to compute, if this >>>>>>>>>>>>>>>>>> is what ALL decider do, is "Halting" the only type of >>>>>>>>>>>>>>>>>> decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a non-input >>>>>>>>>>>>>>>>>>> this only objection
is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE coming to >>>>>>>>>>>>>>>>>> a final state, and it does.
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D correctly >>>>>>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally.
Except YOU are one invocation from the probem. It >>>>>>>>>>>>>>>>>> isn't asking about the simulatiion done by H, but by >>>>>>>>>>>>>>>>>> the machine that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H has >>>>>>>>>>>>>>>>>>> already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the definition >>>>>>>>>>>>>>>>>> of the problem, what does the machine represented by >>>>>>>>>>>>>>>>>> the input do?
The definition of the problem that you are referring to >>>>>>>>>>>>>>>>> contradicts the definition of a decider that must >>>>>>>>>>>>>>>>> compute the mapping from
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state.
You think that H is wrong because the outer invocation >>>>>>>>>>>>>>>>> halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>
You know that it is necessarily true that no invocation >>>>>>>>>>>>>>>>> would ever halt
unless the inner invocation was aborted, thus making >>>>>>>>>>>>>>>>> the termination of
this inner invocation necessarily correct.
I have better words. The termination of the simulation >>>>>>>>>>>>>>>> of D is mandated
by the requirements that a halt decider must always >>>>>>>>>>>>>>>> halt, thus
conclusively proving that this termination is
necessarily correct.
It is also mandated to give the correct answer, which >>>>>>>>>>>>>>> since H(D,D) returns 0, which causes D(D) to Halt, the >>>>>>>>>>>>>>> only correct answer that H(D,D) should give is 1, so it >>>>>>>>>>>>>>> is necessarily incorrect.
The easily verified fact that H itself would not terminate >>>>>>>>>>>>>> unless it
aborted the simulation of its input conclusively proves >>>>>>>>>>>>>> that H is
necessarily correct to do this and report this input as >>>>>>>>>>>>>> non-halting.
This equally applies to the Peter Linz Turing machine >>>>>>>>>>>>>> based halting
problem proof with embedded_H and ⟨Ĥ⟩.
So? H not terminating is its own problem.
would violate this requirement thus making this choice >>>>>>>>>>>> necessarily
correct. This also conclusively proves that its input cannot >>>>>>>>>>>> possibly
terminate normally thus is correctly determined to be
non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, so it >>>>>>>>>>> can't just be programmed to simulate forever. It also is >>>>>>>>>>> required to return the correct answer,
never terminates normally that makes it necessarily correct to >>>>>>>>>> do this.
So, you are admitting that H doesn't actually "terminate
normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully terrible >>>>>>>> to make a mistake like that.
So, does H "Terminate Normally", at which point, so does the D,
or does H not "Terminate Normally" and thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) at
line 03 ...
The simulated D cannot possibly terminate normally and H will
never return to its caller unless and until H aborts its simulation. >>>>>
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it.
We have two IDENTICAL initial sequence of instructions, the entry to
H, in one case from main, and in the other from D, with identical
parameters.
If the results follow different paths, there must be a first point of
departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H to
decide if D(D) will Halt, it should have answered YES, (1)
Because it is an easily verified fact that neither the directly executed
H(D,D) nor the directly executed D(D) would ever terminate normally
unless H aborts its simulation of D, H is necessarily correct to abort
its simulation of D to meet the requirement that itself must halt.
No it DOES terminate because it DOES abort is simulation, since that is
what the code says to do. No need to argue about a fantasy case that
doesn't exist.
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:So, why doesn't that happen when main calls H?
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:Since it is true that unless H aborts its simulation of D >>>>>>>>>>> that H itself
On 5/25/2023 9:42 PM, Richard Damon wrote:
On 5/25/23 10:26 PM, olcott wrote:Since it is required to terminate the choice to not abort >>>>>>>>>>>>> its simulation
On 5/25/2023 8:56 PM, Richard Damon wrote:
On 5/25/23 9:43 PM, olcott wrote:
On 5/25/2023 8:29 PM, olcott wrote:
On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, >>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
Following pseudocode for D:
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) { >>>>>>>>>>>>>>>>>>>>>> n = n + 2
}
return n
}
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)?
Why would you care? PO's H returns "does not halt" >>>>>>>>>>>>>>>>>>>>> for at least some
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest.
PO equivocates over whether he is concerned about >>>>>>>>>>>>>>>>>>>>> just the one case used
in the usual proof's construction or the general >>>>>>>>>>>>>>>>>>>>> case, but regardless of
what side of that fence he is currently sitting, >>>>>>>>>>>>>>>>>>>>> you can't use his H for
anything useful.
How would it know the correct answer? Will it ever >>>>>>>>>>>>>>>>>>>>>> return an answer?On some days he will claim that he has never said >>>>>>>>>>>>>>>>>>>>> he has a general halt
(Especially, _if_ there is no odd perfect number?) >>>>>>>>>>>>>>>>>>>>>
decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>> "usual construction". It
"can't be fooled" because he simply declares that >>>>>>>>>>>>>>>>>>>>> H(H^, H^) == false is
the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind and >>>>>>>>>>>>>>>>>>>>> claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>> computations "augmented" by
some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question for >>>>>>>>>>>>>>>>>>>>> years (literally years),
and he will even say contradictory things days >>>>>>>>>>>>>>>>>>>>> apart (again, citations
available on request) so it can take some time to >>>>>>>>>>>>>>>>>>>>> clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though P(P) >>>>>>>>>>>>>>>>>>>>> halts."
in reply to the question "do you still assert that >>>>>>>>>>>>>>>>>>>>> H(P,P) == false is
the 'correct' answer even though P(P) halts?" I >>>>>>>>>>>>>>>>>>>>> don't see any point in
carrying on, or at least I see not point in saying >>>>>>>>>>>>>>>>>>>>> anything else.
The one weapon we have against cranks is that most >>>>>>>>>>>>>>>>>>>>> can't bear to retract
any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>> usually so evasive about
giving direct answers -- they know they will have >>>>>>>>>>>>>>>>>>>>> to stick with them.
But once they have made the mistake of being clear, >>>>>>>>>>>>>>>>>>>>> we should pay them
the courtesy of quoting them at every available >>>>>>>>>>>>>>>>>>>>> opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a tautology >>>>>>>>>>>>>>>>>>>> thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, which is >>>>>>>>>>>>>>>>>>> just a form of LYING.
The context does not change the fact that he agreed >>>>>>>>>>>>>>>>>> that H does
correctly determine the halt status of D according to >>>>>>>>>>>>>>>>>> the Sisper approved criteria.
Because all deciders only compute the mapping *from >>>>>>>>>>>>>>>>>>>> their inputs* toSO, what mapping is this supposed to compute, if this >>>>>>>>>>>>>>>>>>> is what ALL decider do, is "Halting" the only type of >>>>>>>>>>>>>>>>>>> decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a non-input >>>>>>>>>>>>>>>>>>>> this only objection
is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE coming to >>>>>>>>>>>>>>>>>>> a final state, and it does.
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D correctly >>>>>>>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally.
Except YOU are one invocation from the probem. It >>>>>>>>>>>>>>>>>>> isn't asking about the simulatiion done by H, but by >>>>>>>>>>>>>>>>>>> the machine that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H has >>>>>>>>>>>>>>>>>>>> already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the definition >>>>>>>>>>>>>>>>>>> of the problem, what does the machine represented by >>>>>>>>>>>>>>>>>>> the input do?
The definition of the problem that you are referring >>>>>>>>>>>>>>>>>> to contradicts the definition of a decider that must >>>>>>>>>>>>>>>>>> compute the mapping from
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state.
You think that H is wrong because the outer invocation >>>>>>>>>>>>>>>>>> halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus making >>>>>>>>>>>>>>>>>> the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>
I have better words. The termination of the simulation >>>>>>>>>>>>>>>>> of D is mandated
by the requirements that a halt decider must always >>>>>>>>>>>>>>>>> halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, which >>>>>>>>>>>>>>>> since H(D,D) returns 0, which causes D(D) to Halt, the >>>>>>>>>>>>>>>> only correct answer that H(D,D) should give is 1, so it >>>>>>>>>>>>>>>> is necessarily incorrect.
The easily verified fact that H itself would not >>>>>>>>>>>>>>> terminate unless it
aborted the simulation of its input conclusively proves >>>>>>>>>>>>>>> that H is
necessarily correct to do this and report this input as >>>>>>>>>>>>>>> non-halting.
This equally applies to the Peter Linz Turing machine >>>>>>>>>>>>>>> based halting
problem proof with embedded_H and ⟨Ĥ⟩.
So? H not terminating is its own problem.
would violate this requirement thus making this choice >>>>>>>>>>>>> necessarily
correct. This also conclusively proves that its input >>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, so it >>>>>>>>>>>> can't just be programmed to simulate forever. It also is >>>>>>>>>>>> required to return the correct answer,
never terminates normally that makes it necessarily correct >>>>>>>>>>> to do this.
So, you are admitting that H doesn't actually "terminate
normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully terrible >>>>>>>>> to make a mistake like that.
So, does H "Terminate Normally", at which point, so does the D, >>>>>>>> or does H not "Terminate Normally" and thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) at
line 03 ...
The simulated D cannot possibly terminate normally and H will
never return to its caller unless and until H aborts its simulation. >>>>>>
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it.
We have two IDENTICAL initial sequence of instructions, the entry to
H, in one case from main, and in the other from D, with identical
parameters.
If the results follow different paths, there must be a first point
of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H to
decide if D(D) will Halt, it should have answered YES, (1)
Because it is an easily verified fact that neither the directly executed >>> H(D,D) nor the directly executed D(D) would ever terminate normally
unless H aborts its simulation of D, H is necessarily correct to abort
its simulation of D to meet the requirement that itself must halt.
No it DOES terminate because it DOES abort is simulation, since that
is what the code says to do. No need to argue about a fantasy case
that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system.
(f) At the checkout counter you accuse the head mechanic of lying
because your car clearly does not need to have its exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to jail.
H is asked the question: Does your input need to be aborted to prevent infinite simulation? H correctly answers yes and aborts the simulation.
Countless reviewers disagree on the basis that after H has already
aborted its simulation of its input the simulation of this input does
not need to be aborted.
On 5/26/23 7:31 PM, olcott wrote:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:Since it is true that unless H aborts its simulation of D >>>>>>>>>>>> that H itself
On 5/25/2023 9:42 PM, Richard Damon wrote:
On 5/25/23 10:26 PM, olcott wrote:Since it is required to terminate the choice to not abort >>>>>>>>>>>>>> its simulation
On 5/25/2023 8:56 PM, Richard Damon wrote:
On 5/25/23 9:43 PM, olcott wrote:
On 5/25/2023 8:29 PM, olcott wrote:
On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, >>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
Following pseudocode for D:
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) { >>>>>>>>>>>>>>>>>>>>>>> n = n + 2
}
return n
}
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)?
Why would you care? PO's H returns "does not >>>>>>>>>>>>>>>>>>>>>> halt" for at least some
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest.
PO equivocates over whether he is concerned about >>>>>>>>>>>>>>>>>>>>>> just the one case used
in the usual proof's construction or the general >>>>>>>>>>>>>>>>>>>>>> case, but regardless of
what side of that fence he is currently sitting, >>>>>>>>>>>>>>>>>>>>>> you can't use his H for
anything useful.
How would it know the correct answer? Will it >>>>>>>>>>>>>>>>>>>>>>> ever return an answer?On some days he will claim that he has never said >>>>>>>>>>>>>>>>>>>>>> he has a general halt
(Especially, _if_ there is no odd perfect number?) >>>>>>>>>>>>>>>>>>>>>>
decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>>> "usual construction". It
"can't be fooled" because he simply declares that >>>>>>>>>>>>>>>>>>>>>> H(H^, H^) == false is
the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind and >>>>>>>>>>>>>>>>>>>>>> claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>> computations "augmented" by
some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question for >>>>>>>>>>>>>>>>>>>>>> years (literally years),
and he will even say contradictory things days >>>>>>>>>>>>>>>>>>>>>> apart (again, citations
available on request) so it can take some time to >>>>>>>>>>>>>>>>>>>>>> clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though >>>>>>>>>>>>>>>>>>>>>> P(P) halts."
in reply to the question "do you still assert that >>>>>>>>>>>>>>>>>>>>>> H(P,P) == false is
the 'correct' answer even though P(P) halts?" I >>>>>>>>>>>>>>>>>>>>>> don't see any point in
carrying on, or at least I see not point in saying >>>>>>>>>>>>>>>>>>>>>> anything else.
The one weapon we have against cranks is that most >>>>>>>>>>>>>>>>>>>>>> can't bear to retract
any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>> usually so evasive about
giving direct answers -- they know they will have >>>>>>>>>>>>>>>>>>>>>> to stick with them.
But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>> clear, we should pay them
the courtesy of quoting them at every available >>>>>>>>>>>>>>>>>>>>>> opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a tautology >>>>>>>>>>>>>>>>>>>>> thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, which >>>>>>>>>>>>>>>>>>>> is just a form of LYING.
The context does not change the fact that he agreed >>>>>>>>>>>>>>>>>>> that H does
correctly determine the halt status of D according to >>>>>>>>>>>>>>>>>>> the Sisper approved criteria.
Because all deciders only compute the mapping *from >>>>>>>>>>>>>>>>>>>>> their inputs* toSO, what mapping is this supposed to compute, if >>>>>>>>>>>>>>>>>>>> this is what ALL decider do, is "Halting" the only >>>>>>>>>>>>>>>>>>>> type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a non-input >>>>>>>>>>>>>>>>>>>>> this only objection
is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE coming >>>>>>>>>>>>>>>>>>>> to a final state, and it does.
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally.
Except YOU are one invocation from the probem. It >>>>>>>>>>>>>>>>>>>> isn't asking about the simulatiion done by H, but by >>>>>>>>>>>>>>>>>>>> the machine that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H has >>>>>>>>>>>>>>>>>>>>> already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>> definition of the problem, what does the machine >>>>>>>>>>>>>>>>>>>> represented by the input do?
The definition of the problem that you are referring >>>>>>>>>>>>>>>>>>> to contradicts the definition of a decider that must >>>>>>>>>>>>>>>>>>> compute the mapping from
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state.
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus making >>>>>>>>>>>>>>>>>>> the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>
I have better words. The termination of the simulation >>>>>>>>>>>>>>>>>> of D is mandated
by the requirements that a halt decider must always >>>>>>>>>>>>>>>>>> halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, which >>>>>>>>>>>>>>>>> since H(D,D) returns 0, which causes D(D) to Halt, the >>>>>>>>>>>>>>>>> only correct answer that H(D,D) should give is 1, so it >>>>>>>>>>>>>>>>> is necessarily incorrect.
The easily verified fact that H itself would not >>>>>>>>>>>>>>>> terminate unless it
aborted the simulation of its input conclusively proves >>>>>>>>>>>>>>>> that H is
necessarily correct to do this and report this input as >>>>>>>>>>>>>>>> non-halting.
This equally applies to the Peter Linz Turing machine >>>>>>>>>>>>>>>> based halting
problem proof with embedded_H and ⟨Ĥ⟩.
So? H not terminating is its own problem.
would violate this requirement thus making this choice >>>>>>>>>>>>>> necessarily
correct. This also conclusively proves that its input >>>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, so it >>>>>>>>>>>>> can't just be programmed to simulate forever. It also is >>>>>>>>>>>>> required to return the correct answer,
never terminates normally that makes it necessarily correct >>>>>>>>>>>> to do this.
So, you are admitting that H doesn't actually "terminate >>>>>>>>>>> normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully terrible >>>>>>>>>> to make a mistake like that.
So, does H "Terminate Normally", at which point, so does the D, >>>>>>>>> or does H not "Terminate Normally" and thus isn't a decider? >>>>>>>>>
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ... >>>>>>>>
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) at >>>>>>>> line 03 ...
The simulated D cannot possibly terminate normally and H will
never return to its caller unless and until H aborts its
simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it.
We have two IDENTICAL initial sequence of instructions, the entry
to H, in one case from main, and in the other from D, with
identical parameters.
If the results follow different paths, there must be a first point
of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H to
decide if D(D) will Halt, it should have answered YES, (1)
Because it is an easily verified fact that neither the directly
executed
H(D,D) nor the directly executed D(D) would ever terminate normally
unless H aborts its simulation of D, H is necessarily correct to abort >>>> its simulation of D to meet the requirement that itself must halt.
No it DOES terminate because it DOES abort is simulation, since that
is what the code says to do. No need to argue about a fantasy case
that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system.
(f) At the checkout counter you accuse the head mechanic of lying
because your car clearly does not need to have its exhaust system >> replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to jail.
H is asked the question: Does your input need to be aborted to prevent
infinite simulation? H correctly answers yes and aborts the simulation.
Nope, H is asked the question, does the machine represented by your
input finish running in finite time?
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:Since it is true that unless H aborts its simulation of D >>>>>>>>>>>>> that H itself
On 5/25/2023 9:42 PM, Richard Damon wrote:
On 5/25/23 10:26 PM, olcott wrote:Since it is required to terminate the choice to not abort >>>>>>>>>>>>>>> its simulation
On 5/25/2023 8:56 PM, Richard Damon wrote:
On 5/25/23 9:43 PM, olcott wrote:
On 5/25/2023 8:29 PM, olcott wrote:
On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>> writes:
On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, >>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
Following pseudocode for D:
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) { >>>>>>>>>>>>>>>>>>>>>>>> n = n + 2
}
return n
}
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)?
Why would you care? PO's H returns "does not >>>>>>>>>>>>>>>>>>>>>>> halt" for at least some
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest.
PO equivocates over whether he is concerned about >>>>>>>>>>>>>>>>>>>>>>> just the one case used
in the usual proof's construction or the general >>>>>>>>>>>>>>>>>>>>>>> case, but regardless of
what side of that fence he is currently sitting, >>>>>>>>>>>>>>>>>>>>>>> you can't use his H for
anything useful.
How would it know the correct answer? Will it >>>>>>>>>>>>>>>>>>>>>>>> ever return an answer?On some days he will claim that he has never said >>>>>>>>>>>>>>>>>>>>>>> he has a general halt
(Especially, _if_ there is no odd perfect number?) >>>>>>>>>>>>>>>>>>>>>>>
decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>>>> "usual construction". It
"can't be fooled" because he simply declares that >>>>>>>>>>>>>>>>>>>>>>> H(H^, H^) == false is
the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind and >>>>>>>>>>>>>>>>>>>>>>> claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by
some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question for >>>>>>>>>>>>>>>>>>>>>>> years (literally years),
and he will even say contradictory things days >>>>>>>>>>>>>>>>>>>>>>> apart (again, citations
available on request) so it can take some time to >>>>>>>>>>>>>>>>>>>>>>> clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though >>>>>>>>>>>>>>>>>>>>>>> P(P) halts."
in reply to the question "do you still assert >>>>>>>>>>>>>>>>>>>>>>> that H(P,P) == false is
the 'correct' answer even though P(P) halts?" I >>>>>>>>>>>>>>>>>>>>>>> don't see any point in
carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>> saying anything else.
The one weapon we have against cranks is that >>>>>>>>>>>>>>>>>>>>>>> most can't bear to retract
any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>>> usually so evasive about
giving direct answers -- they know they will have >>>>>>>>>>>>>>>>>>>>>>> to stick with them.
But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>>> clear, we should pay them
the courtesy of quoting them at every available >>>>>>>>>>>>>>>>>>>>>>> opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a tautology >>>>>>>>>>>>>>>>>>>>>> thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, which >>>>>>>>>>>>>>>>>>>>> is just a form of LYING.
The context does not change the fact that he agreed >>>>>>>>>>>>>>>>>>>> that H does
correctly determine the halt status of D according >>>>>>>>>>>>>>>>>>>> to the Sisper approved criteria.
Because all deciders only compute the mapping >>>>>>>>>>>>>>>>>>>>>> *from their inputs* toSO, what mapping is this supposed to compute, if >>>>>>>>>>>>>>>>>>>>> this is what ALL decider do, is "Halting" the only >>>>>>>>>>>>>>>>>>>>> type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>> non-input this only objection
is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE coming >>>>>>>>>>>>>>>>>>>>> to a final state, and it does.
Except YOU are one invocation from the probem. It >>>>>>>>>>>>>>>>>>>>> isn't asking about the simulatiion done by H, but >>>>>>>>>>>>>>>>>>>>> by the machine that H is TRYING to simulate (but >>>>>>>>>>>>>>>>>>>>> can't).
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H >>>>>>>>>>>>>>>>>>>>>> has already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the machine >>>>>>>>>>>>>>>>>>>>> represented by the input do?
The definition of the problem that you are referring >>>>>>>>>>>>>>>>>>>> to contradicts the definition of a decider that must >>>>>>>>>>>>>>>>>>>> compute the mapping from
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state.
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus making >>>>>>>>>>>>>>>>>>>> the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must always >>>>>>>>>>>>>>>>>>> halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, which >>>>>>>>>>>>>>>>>> since H(D,D) returns 0, which causes D(D) to Halt, the >>>>>>>>>>>>>>>>>> only correct answer that H(D,D) should give is 1, so >>>>>>>>>>>>>>>>>> it is necessarily incorrect.
The easily verified fact that H itself would not >>>>>>>>>>>>>>>>> terminate unless it
aborted the simulation of its input conclusively proves >>>>>>>>>>>>>>>>> that H is
necessarily correct to do this and report this input as >>>>>>>>>>>>>>>>> non-halting.
This equally applies to the Peter Linz Turing machine >>>>>>>>>>>>>>>>> based halting
problem proof with embedded_H and ⟨Ĥ⟩.
So? H not terminating is its own problem.
would violate this requirement thus making this choice >>>>>>>>>>>>>>> necessarily
correct. This also conclusively proves that its input >>>>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, so >>>>>>>>>>>>>> it can't just be programmed to simulate forever. It also >>>>>>>>>>>>>> is required to return the correct answer,
never terminates normally that makes it necessarily correct >>>>>>>>>>>>> to do this.
So, you are admitting that H doesn't actually "terminate >>>>>>>>>>>> normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully
terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does the >>>>>>>>>> D, or does H not "Terminate Normally" and thus isn't a decider? >>>>>>>>>>
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ... >>>>>>>>>
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) at >>>>>>>>> line 03 ...
The simulated D cannot possibly terminate normally and H will >>>>>>>>> never return to its caller unless and until H aborts its
simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it.
We have two IDENTICAL initial sequence of instructions, the entry
to H, in one case from main, and in the other from D, with
identical parameters.
If the results follow different paths, there must be a first point >>>>>> of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the inner >>>>> invocation. Directly executed H(D,D) always behaves exactly the same >>>>> way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H to
decide if D(D) will Halt, it should have answered YES, (1)
Because it is an easily verified fact that neither the directly
executed
H(D,D) nor the directly executed D(D) would ever terminate normally
unless H aborts its simulation of D, H is necessarily correct to abort >>>>> its simulation of D to meet the requirement that itself must halt.
No it DOES terminate because it DOES abort is simulation, since that
is what the code says to do. No need to argue about a fantasy case
that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system.
(f) At the checkout counter you accuse the head mechanic of lying
because your car clearly does not need to have its exhaust system >>> replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to jail.
H is asked the question: Does your input need to be aborted to
prevent infinite simulation? H correctly answers yes and aborts the
simulation.
Nope, H is asked the question, does the machine represented by your
input finish running in finite time?
Does my exhaust system need to be replaced after you just replaced it?
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:Since it is true that unless H aborts its simulation of D >>>>>>>>>>>>>>> that H itself
On 5/25/2023 9:42 PM, Richard Damon wrote:
On 5/25/23 10:26 PM, olcott wrote:Since it is required to terminate the choice to not >>>>>>>>>>>>>>>>> abort its simulation
On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
The easily verified fact that H itself would not >>>>>>>>>>>>>>>>>>> terminate unless itOn 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>>> writes:
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) { >>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>> }
return n
}
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)?
Why would you care? PO's H returns "does not >>>>>>>>>>>>>>>>>>>>>>>>> halt" for at least some
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is concerned >>>>>>>>>>>>>>>>>>>>>>>>> about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>> anything useful.
How would it know the correct answer? Will it >>>>>>>>>>>>>>>>>>>>>>>>>> ever return an answer?
(Especially, _if_ there is no odd perfect >>>>>>>>>>>>>>>>>>>>>>>>>> number?)
On some days he will claim that he has never >>>>>>>>>>>>>>>>>>>>>>>>> said he has a general halt
decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>>>>>> "usual construction". It
"can't be fooled" because he simply declares >>>>>>>>>>>>>>>>>>>>>>>>> that H(H^, H^) == false is
the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind >>>>>>>>>>>>>>>>>>>>>>>>> and claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by
some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question for >>>>>>>>>>>>>>>>>>>>>>>>> years (literally years),
and he will even say contradictory things days >>>>>>>>>>>>>>>>>>>>>>>>> apart (again, citations
available on request) so it can take some time >>>>>>>>>>>>>>>>>>>>>>>>> to clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though >>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts."
in reply to the question "do you still assert >>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P) == false is
the 'correct' answer even though P(P) halts?" I >>>>>>>>>>>>>>>>>>>>>>>>> don't see any point in
carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>>>> saying anything else.
The one weapon we have against cranks is that >>>>>>>>>>>>>>>>>>>>>>>>> most can't bear to retract
any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>>>>> usually so evasive about
giving direct answers -- they know they will >>>>>>>>>>>>>>>>>>>>>>>>> have to stick with them.
But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>>>>> clear, we should pay them
the courtesy of quoting them at every available >>>>>>>>>>>>>>>>>>>>>>>>> opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, >>>>>>>>>>>>>>>>>>>>>>> which is just a form of LYING.
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D according >>>>>>>>>>>>>>>>>>>>>> to the Sisper approved criteria.
Because all deciders only compute the mapping >>>>>>>>>>>>>>>>>>>>>>>> *from their inputs* toSO, what mapping is this supposed to compute, if >>>>>>>>>>>>>>>>>>>>>>> this is what ALL decider do, is "Halting" the >>>>>>>>>>>>>>>>>>>>>>> only type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection
is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the probem. It >>>>>>>>>>>>>>>>>>>>>>> isn't asking about the simulatiion done by H, but >>>>>>>>>>>>>>>>>>>>>>> by the machine that H is TRYING to simulate (but >>>>>>>>>>>>>>>>>>>>>>> can't).
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H >>>>>>>>>>>>>>>>>>>>>>>> has already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the machine >>>>>>>>>>>>>>>>>>>>>>> represented by the input do?
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>>> making the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must always >>>>>>>>>>>>>>>>>>>>> halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, >>>>>>>>>>>>>>>>>>>> which since H(D,D) returns 0, which causes D(D) to >>>>>>>>>>>>>>>>>>>> Halt, the only correct answer that H(D,D) should >>>>>>>>>>>>>>>>>>>> give is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this input >>>>>>>>>>>>>>>>>>> as non-halting.
This equally applies to the Peter Linz Turing machine >>>>>>>>>>>>>>>>>>> based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem.
would violate this requirement thus making this choice >>>>>>>>>>>>>>>>> necessarily
correct. This also conclusively proves that its input >>>>>>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, so >>>>>>>>>>>>>>>> it can't just be programmed to simulate forever. It also >>>>>>>>>>>>>>>> is required to return the correct answer,
never terminates normally that makes it necessarily >>>>>>>>>>>>>>> correct to do this.
So, you are admitting that H doesn't actually "terminate >>>>>>>>>>>>>> normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully >>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does the >>>>>>>>>>>> D, or does H not "Terminate Normally" and thus isn't a decider? >>>>>>>>>>>>
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ... >>>>>>>>>>>
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) >>>>>>>>>>> at line 03 ...
The simulated D cannot possibly terminate normally and H will >>>>>>>>>>> never return to its caller unless and until H aborts its >>>>>>>>>>> simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it. >>>>>>>
We have two IDENTICAL initial sequence of instructions, the
entry to H, in one case from main, and in the other from D, with >>>>>>>> identical parameters.
If the results follow different paths, there must be a first
point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the
inner
invocation. Directly executed H(D,D) always behaves exactly the same >>>>>>> way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H to >>>>>> decide if D(D) will Halt, it should have answered YES, (1)
No it DOES terminate because it DOES abort is simulation, since
Because it is an easily verified fact that neither the directly
executed
H(D,D) nor the directly executed D(D) would ever terminate normally >>>>>>> unless H aborts its simulation of D, H is necessarily correct to >>>>>>> abort
its simulation of D to meet the requirement that itself must halt. >>>>>>
that is what the code says to do. No need to argue about a fantasy >>>>>> case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system.
(f) At the checkout counter you accuse the head mechanic of lying
because your car clearly does not need to have its exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to jail. >>>>>
H is asked the question: Does your input need to be aborted to
prevent infinite simulation? H correctly answers yes and aborts
the simulation.
Nope, H is asked the question, does the machine represented by your
input finish running in finite time?
Does my exhaust system need to be replaced after you just replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Is proven to be incorrect on the basis of after
(a) The exhaust system has been replaced.
(b) The simulation of the input has been aborted.
The answer to the original question becomes NO.
The answer to the question:
Is it possible for D correctly simulated by H to terminate normally? Competent and honest software engineers concur
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:never terminates normally that makes it necessarily >>>>>>>>>>>>>>>> correct to do this.
On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote:
would violate this requirement thus making this choice >>>>>>>>>>>>>>>>>> necessarilyOn 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
The easily verified fact that H itself would not >>>>>>>>>>>>>>>>>>>> terminate unless itOn 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>>>> writes:
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns "does not >>>>>>>>>>>>>>>>>>>>>>>>>> halt" for at least some
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>> }
return n >>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is concerned >>>>>>>>>>>>>>>>>>>>>>>>>> about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>> anything useful.
How would it know the correct answer? Will it >>>>>>>>>>>>>>>>>>>>>>>>>>> ever return an answer?
(Especially, _if_ there is no odd perfect >>>>>>>>>>>>>>>>>>>>>>>>>>> number?)
On some days he will claim that he has never >>>>>>>>>>>>>>>>>>>>>>>>>> said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>>>>>>> "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply declares >>>>>>>>>>>>>>>>>>>>>>>>>> that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind >>>>>>>>>>>>>>>>>>>>>>>>>> and claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question >>>>>>>>>>>>>>>>>>>>>>>>>> for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory things days >>>>>>>>>>>>>>>>>>>>>>>>>> apart (again, citations
available on request) so it can take some time >>>>>>>>>>>>>>>>>>>>>>>>>> to clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though >>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts."
in reply to the question "do you still assert >>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P) == false is
the 'correct' answer even though P(P) halts?" >>>>>>>>>>>>>>>>>>>>>>>>>> I don't see any point in
carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>>>>> saying anything else.
The one weapon we have against cranks is that >>>>>>>>>>>>>>>>>>>>>>>>>> most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>>>>>> usually so evasive about
giving direct answers -- they know they will >>>>>>>>>>>>>>>>>>>>>>>>>> have to stick with them.
But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>>>>>> clear, we should pay them
the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, >>>>>>>>>>>>>>>>>>>>>>>> which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>> *from their inputs* toSO, what mapping is this supposed to compute, if >>>>>>>>>>>>>>>>>>>>>>>> this is what ALL decider do, is "Halting" the >>>>>>>>>>>>>>>>>>>>>>>> only type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the probem. >>>>>>>>>>>>>>>>>>>>>>>> It isn't asking about the simulatiion done by H, >>>>>>>>>>>>>>>>>>>>>>>> but by the machine that H is TRYING to simulate >>>>>>>>>>>>>>>>>>>>>>>> (but can't).
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H >>>>>>>>>>>>>>>>>>>>>>>>> has already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the machine >>>>>>>>>>>>>>>>>>>>>>>> represented by the input do?
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>>>> making the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, >>>>>>>>>>>>>>>>>>>>> which since H(D,D) returns 0, which causes D(D) to >>>>>>>>>>>>>>>>>>>>> Halt, the only correct answer that H(D,D) should >>>>>>>>>>>>>>>>>>>>> give is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this input >>>>>>>>>>>>>>>>>>>> as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to not >>>>>>>>>>>>>>>>>> abort its simulation
correct. This also conclusively proves that its input >>>>>>>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, >>>>>>>>>>>>>>>>> so it can't just be programmed to simulate forever. It >>>>>>>>>>>>>>>>> also is required to return the correct answer, >>>>>>>>>>>>>>>> Since it is true that unless H aborts its simulation of >>>>>>>>>>>>>>>> D that H itself
So, you are admitting that H doesn't actually "terminate >>>>>>>>>>>>>>> normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully >>>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does >>>>>>>>>>>>> the D, or does H not "Terminate Normally" and thus isn't a >>>>>>>>>>>>> decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ... >>>>>>>>>>>>
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) >>>>>>>>>>>> at line 03 ...
The simulated D cannot possibly terminate normally and H will >>>>>>>>>>>> never return to its caller unless and until H aborts its >>>>>>>>>>>> simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it. >>>>>>>>
We have two IDENTICAL initial sequence of instructions, the
entry to H, in one case from main, and in the other from D,
with identical parameters.
If the results follow different paths, there must be a first >>>>>>>>> point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the >>>>>>>> inner
invocation. Directly executed H(D,D) always behaves exactly the >>>>>>>> same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H
to decide if D(D) will Halt, it should have answered YES, (1)
No it DOES terminate because it DOES abort is simulation, since
Because it is an easily verified fact that neither the directly >>>>>>>> executed
H(D,D) nor the directly executed D(D) would ever terminate normally >>>>>>>> unless H aborts its simulation of D, H is necessarily correct to >>>>>>>> abort
its simulation of D to meet the requirement that itself must halt. >>>>>>>
that is what the code says to do. No need to argue about a
fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system. >>>>>> (d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system. >>>>>> (f) At the checkout counter you accuse the head mechanic of lying
because your car clearly does not need to have its exhaust >>>>>> system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to
jail.
H is asked the question: Does your input need to be aborted to
prevent infinite simulation? H correctly answers yes and aborts
the simulation.
Nope, H is asked the question, does the machine represented by your
input finish running in finite time?
Does my exhaust system need to be replaced after you just replaced it? >>>>
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state when run?"
You are just working with the strawman built out of the straw in your
brain.
You keep repeating that error and ducking the question you can not
answer because you are just lying about what you are doing.
Is proven to be incorrect on the basis of after
(a) The exhaust system has been replaced.
(b) The simulation of the input has been aborted.
The answer to the original question becomes NO.
WRONG, the question was NEVER about H's simulation, but about the
behavior of the machine described.
You changed the spark plugs instead of the exhaust system.
The answer to the question:
Is it possible for D correctly simulated by H to terminate normally?
Competent and honest software engineers concur
But that isn't the question, showing you are a liar.
Show a reliable source, not you, that says a Halt Decider needs to
answer the question the way you are asking.
Remember, if H stops its simulation, it isn't a UTM, so a question about
UTM simulation isn't asking about H's simulation.
You can't, because everything you have done is based on LIES.
On 5/26/23 7:50 PM, olcott wrote:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote:
On 5/25/23 10:55 PM, olcott wrote:Since it is true that unless H aborts its simulation of D >>>>>>>>>>>>>> that H itself
On 5/25/2023 9:42 PM, Richard Damon wrote:
On 5/25/23 10:26 PM, olcott wrote:Since it is required to terminate the choice to not >>>>>>>>>>>>>>>> abort its simulation
On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
On 5/25/2023 8:29 PM, olcott wrote:
On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>> writes:
On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, >>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
Following pseudocode for D:
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) { >>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2
}
return n
}
What would Olcott's "simulating halt decider" >>>>>>>>>>>>>>>>>>>>>>>>> return (answer) if
called with, say, H(D, 1)?
Why would you care? PO's H returns "does not >>>>>>>>>>>>>>>>>>>>>>>> halt" for at least some
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is concerned >>>>>>>>>>>>>>>>>>>>>>>> about just the one case used
in the usual proof's construction or the general >>>>>>>>>>>>>>>>>>>>>>>> case, but regardless of
what side of that fence he is currently sitting, >>>>>>>>>>>>>>>>>>>>>>>> you can't use his H for
anything useful.
How would it know the correct answer? Will it >>>>>>>>>>>>>>>>>>>>>>>>> ever return an answer?On some days he will claim that he has never >>>>>>>>>>>>>>>>>>>>>>>> said he has a general halt
(Especially, _if_ there is no odd perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>
decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>>>>> "usual construction". It
"can't be fooled" because he simply declares >>>>>>>>>>>>>>>>>>>>>>>> that H(H^, H^) == false is
the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind and >>>>>>>>>>>>>>>>>>>>>>>> claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by
some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest disputant, >>>>>>>>>>>>>>>>>>>>>>>> because he will avoid
giving a direct answer to a simple question for >>>>>>>>>>>>>>>>>>>>>>>> years (literally years),
and he will even say contradictory things days >>>>>>>>>>>>>>>>>>>>>>>> apart (again, citations
available on request) so it can take some time >>>>>>>>>>>>>>>>>>>>>>>> to clear all the smoke
from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even though >>>>>>>>>>>>>>>>>>>>>>>> P(P) halts."
in reply to the question "do you still assert >>>>>>>>>>>>>>>>>>>>>>>> that H(P,P) == false is
the 'correct' answer even though P(P) halts?" I >>>>>>>>>>>>>>>>>>>>>>>> don't see any point in
carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>>> saying anything else.
The one weapon we have against cranks is that >>>>>>>>>>>>>>>>>>>>>>>> most can't bear to retract
any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>>>> usually so evasive about
giving direct answers -- they know they will >>>>>>>>>>>>>>>>>>>>>>>> have to stick with them.
But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>>>> clear, we should pay them
the courtesy of quoting them at every available >>>>>>>>>>>>>>>>>>>>>>>> opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>>> determine that halt status
of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily
true.
Nope, you MIS-QUOTE him by removing context, which >>>>>>>>>>>>>>>>>>>>>> is just a form of LYING.
The context does not change the fact that he agreed >>>>>>>>>>>>>>>>>>>>> that H does
correctly determine the halt status of D according >>>>>>>>>>>>>>>>>>>>> to the Sisper approved criteria.
Because all deciders only compute the mapping >>>>>>>>>>>>>>>>>>>>>>> *from their inputs* toSO, what mapping is this supposed to compute, if >>>>>>>>>>>>>>>>>>>>>> this is what ALL decider do, is "Halting" the only >>>>>>>>>>>>>>>>>>>>>> type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>> non-input this only objection
is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE coming >>>>>>>>>>>>>>>>>>>>>> to a final state, and it does.
Except YOU are one invocation from the probem. It >>>>>>>>>>>>>>>>>>>>>> isn't asking about the simulatiion done by H, but >>>>>>>>>>>>>>>>>>>>>> by the machine that H is TRYING to simulate (but >>>>>>>>>>>>>>>>>>>>>> can't).
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after H >>>>>>>>>>>>>>>>>>>>>>> has already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the machine >>>>>>>>>>>>>>>>>>>>>> represented by the input do?
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>> making the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must always >>>>>>>>>>>>>>>>>>>> halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, which >>>>>>>>>>>>>>>>>>> since H(D,D) returns 0, which causes D(D) to Halt, >>>>>>>>>>>>>>>>>>> the only correct answer that H(D,D) should give is 1, >>>>>>>>>>>>>>>>>>> so it is necessarily incorrect.
The easily verified fact that H itself would not >>>>>>>>>>>>>>>>>> terminate unless it
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this input >>>>>>>>>>>>>>>>>> as non-halting.
This equally applies to the Peter Linz Turing machine >>>>>>>>>>>>>>>>>> based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem.
would violate this requirement thus making this choice >>>>>>>>>>>>>>>> necessarily
correct. This also conclusively proves that its input >>>>>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, so >>>>>>>>>>>>>>> it can't just be programmed to simulate forever. It also >>>>>>>>>>>>>>> is required to return the correct answer,
never terminates normally that makes it necessarily >>>>>>>>>>>>>> correct to do this.
So, you are admitting that H doesn't actually "terminate >>>>>>>>>>>>> normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully
terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does the >>>>>>>>>>> D, or does H not "Terminate Normally" and thus isn't a decider? >>>>>>>>>>>
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 ... >>>>>>>>>>
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) at >>>>>>>>>> line 03 ...
The simulated D cannot possibly terminate normally and H will >>>>>>>>>> never return to its caller unless and until H aborts its
simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it. >>>>>>
We have two IDENTICAL initial sequence of instructions, the entry >>>>>>> to H, in one case from main, and in the other from D, with
identical parameters.
If the results follow different paths, there must be a first
point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the inner >>>>>> invocation. Directly executed H(D,D) always behaves exactly the same >>>>>> way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H to
decide if D(D) will Halt, it should have answered YES, (1)
Because it is an easily verified fact that neither the directly
executed
H(D,D) nor the directly executed D(D) would ever terminate normally >>>>>> unless H aborts its simulation of D, H is necessarily correct to
abort
its simulation of D to meet the requirement that itself must halt.
No it DOES terminate because it DOES abort is simulation, since
that is what the code says to do. No need to argue about a fantasy
case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system.
(f) At the checkout counter you accuse the head mechanic of lying
because your car clearly does not need to have its exhaust system >>>> replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to jail. >>>>
H is asked the question: Does your input need to be aborted to
prevent infinite simulation? H correctly answers yes and aborts the
simulation.
Nope, H is asked the question, does the machine represented by your
input finish running in finite time?
Does my exhaust system need to be replaced after you just replaced it?
Why do you say that?
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote:
Since it is true that unless H aborts its simulation >>>>>>>>>>>>>>>>>>>> of D that H itselfOn 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase
would violate this requirement thus making this >>>>>>>>>>>>>>>>>>>>>> choice necessarilyThe easily verified fact that H itself would not >>>>>>>>>>>>>>>>>>>>>>>> terminate unless it<franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns "does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations available >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful.
How would it know the correct answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number?)
On some days he will claim that he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
On other days, he throws caution to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory things >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing context, >>>>>>>>>>>>>>>>>>>>>>>>>>>> which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider do, is >>>>>>>>>>>>>>>>>>>>>>>>>>>> "Halting" the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the machine >>>>>>>>>>>>>>>>>>>>>>>>>>>> that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the >>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>> after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>>>>>>> invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>>>>>>>> making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, >>>>>>>>>>>>>>>>>>>>>>>>> which since H(D,D) returns 0, which causes D(D) >>>>>>>>>>>>>>>>>>>>>>>>> to Halt, the only correct answer that H(D,D) >>>>>>>>>>>>>>>>>>>>>>>>> should give is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>>
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this >>>>>>>>>>>>>>>>>>>>>>>> input as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to >>>>>>>>>>>>>>>>>>>>>> not abort its simulation
correct. This also conclusively proves that its >>>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally thus is correctly determined to >>>>>>>>>>>>>>>>>>>>>> be non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite >>>>>>>>>>>>>>>>>>>>> time, so it can't just be programmed to simulate >>>>>>>>>>>>>>>>>>>>> forever. It also is required to return the correct >>>>>>>>>>>>>>>>>>>>> answer,
never terminates normally that makes it necessarily >>>>>>>>>>>>>>>>>>>> correct to do this.
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite awfully >>>>>>>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so >>>>>>>>>>>>>>>>> does the D, or does H not "Terminate Normally" and thus >>>>>>>>>>>>>>>>> isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line >>>>>>>>>>>>>>>> 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates >>>>>>>>>>>>>>>> D(D) at line 03 ...
The simulated D cannot possibly terminate normally and H >>>>>>>>>>>>>>>> will
never return to its caller unless and until H aborts its >>>>>>>>>>>>>>>> simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what >>>>>>>>>>>> calls it.
We have two IDENTICAL initial sequence of instructions, the >>>>>>>>>>>>> entry to H, in one case from main, and in the other from D, >>>>>>>>>>>>> with identical parameters.
If the results follow different paths, there must be a >>>>>>>>>>>>> first point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as >>>>>>>>>>>> the inner
invocation. Directly executed H(D,D) always behaves exactly >>>>>>>>>>>> the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking >>>>>>>>>>> H to decide if D(D) will Halt, it should have answered YES, (1) >>>>>>>>>>>
Because it is an easily verified fact that neither the >>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever terminate >>>>>>>>>>>> normally
unless H aborts its simulation of D, H is necessarily
correct to abort
its simulation of D to meet the requirement that itself must >>>>>>>>>>>> halt.
No it DOES terminate because it DOES abort is simulation, >>>>>>>>>>> since that is what the code says to do. No need to argue >>>>>>>>>>> about a fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system. >>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust >>>>>>>>>> system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust >>>>>>>>>> system.
(f) At the checkout counter you accuse the head mechanic of lying >>>>>>>>>> because your car clearly does not need to have its >>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go >>>>>>>>>> to jail.
H is asked the question: Does your input need to be aborted to >>>>>>>>>> prevent infinite simulation? H correctly answers yes and >>>>>>>>>> aborts the simulation.
Nope, H is asked the question, does the machine represented by >>>>>>>>> your input finish running in finite time?
Does my exhaust system need to be replaced after you just
replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state when
run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you to
be a LIAR. NO ONE (except you) is interested in your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to run
forever.
We can't say that D(D) halts on the basis that its otherwise infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you have
defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific
program. You H DOES abort at a specific point, and something that does something different is a different program.
Maybe you just don't understand that a program is what it has actually
been programmed to be. Maybe you lost your job as a programmer because
you don't actually understand what a program is.
This is exactly the same thing as saying that the mechanic lied about
your car needing a new exhaust system because it doesn't need one after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it halt.
Do you deny that? That is what you program shows.
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote:
never terminates normally that makes it necessarily >>>>>>>>>>>>>>>>>> correct to do this.On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote:
would violate this requirement thus making this >>>>>>>>>>>>>>>>>>>> choice necessarilyOn 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase
The easily verified fact that H itself would not >>>>>>>>>>>>>>>>>>>>>> terminate unless it<franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns "does >>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>>>>>>>> request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is concerned >>>>>>>>>>>>>>>>>>>>>>>>>>>> about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful.
How would it know the correct answer? Will >>>>>>>>>>>>>>>>>>>>>>>>>>>>> it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>> number?)
On some days he will claim that he has never >>>>>>>>>>>>>>>>>>>>>>>>>>>> said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled by >>>>>>>>>>>>>>>>>>>>>>>>>>>> the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply declares >>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind >>>>>>>>>>>>>>>>>>>>>>>>>>>> and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple question >>>>>>>>>>>>>>>>>>>>>>>>>>>> for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory things >>>>>>>>>>>>>>>>>>>>>>>>>>>> days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take some >>>>>>>>>>>>>>>>>>>>>>>>>>>> time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts."
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>>>>>>> saying anything else.
The one weapon we have against cranks is >>>>>>>>>>>>>>>>>>>>>>>>>>>> that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>>>>>>>> usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they will >>>>>>>>>>>>>>>>>>>>>>>>>>>> have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>>>>>>>> clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing context, >>>>>>>>>>>>>>>>>>>>>>>>>> which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>> *from their inputs* toSO, what mapping is this supposed to compute, >>>>>>>>>>>>>>>>>>>>>>>>>> if this is what ALL decider do, is "Halting" >>>>>>>>>>>>>>>>>>>>>>>>>> the only type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>>>>>>>> objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the probem. >>>>>>>>>>>>>>>>>>>>>>>>>> It isn't asking about the simulatiion done by >>>>>>>>>>>>>>>>>>>>>>>>>> H, but by the machine that H is TRYING to >>>>>>>>>>>>>>>>>>>>>>>>>> simulate (but can't).
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after >>>>>>>>>>>>>>>>>>>>>>>>>>> H has already made this
correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the >>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly >>>>>>>>>>>>>>>>>>>>>>>>> aborted.
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>>>>>> making the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, >>>>>>>>>>>>>>>>>>>>>>> which since H(D,D) returns 0, which causes D(D) >>>>>>>>>>>>>>>>>>>>>>> to Halt, the only correct answer that H(D,D) >>>>>>>>>>>>>>>>>>>>>>> should give is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this >>>>>>>>>>>>>>>>>>>>>> input as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to not >>>>>>>>>>>>>>>>>>>> abort its simulation
correct. This also conclusively proves that its >>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally thus is correctly determined to >>>>>>>>>>>>>>>>>>>> be non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, >>>>>>>>>>>>>>>>>>> so it can't just be programmed to simulate forever. >>>>>>>>>>>>>>>>>>> It also is required to return the correct answer, >>>>>>>>>>>>>>>>>> Since it is true that unless H aborts its simulation >>>>>>>>>>>>>>>>>> of D that H itself
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>
Your software engineering skill must be quite awfully >>>>>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does >>>>>>>>>>>>>>> the D, or does H not "Terminate Normally" and thus isn't >>>>>>>>>>>>>>> a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line >>>>>>>>>>>>>> 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates >>>>>>>>>>>>>> D(D) at line 03 ...
The simulated D cannot possibly terminate normally and H will >>>>>>>>>>>>>> never return to its caller unless and until H aborts its >>>>>>>>>>>>>> simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls >>>>>>>>>> it.
We have two IDENTICAL initial sequence of instructions, the >>>>>>>>>>> entry to H, in one case from main, and in the other from D, >>>>>>>>>>> with identical parameters.
If the results follow different paths, there must be a first >>>>>>>>>>> point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as >>>>>>>>>> the inner
invocation. Directly executed H(D,D) always behaves exactly >>>>>>>>>> the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H >>>>>>>>> to decide if D(D) will Halt, it should have answered YES, (1) >>>>>>>>>
Because it is an easily verified fact that neither the
directly executed
H(D,D) nor the directly executed D(D) would ever terminate >>>>>>>>>> normally
unless H aborts its simulation of D, H is necessarily correct >>>>>>>>>> to abort
its simulation of D to meet the requirement that itself must >>>>>>>>>> halt.
No it DOES terminate because it DOES abort is simulation, since >>>>>>>>> that is what the code says to do. No need to argue about a
fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system. >>>>>>>> (d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system. >>>>>>>> (f) At the checkout counter you accuse the head mechanic of lying >>>>>>>> because your car clearly does not need to have its exhaust >>>>>>>> system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to >>>>>>>> jail.
H is asked the question: Does your input need to be aborted to >>>>>>>> prevent infinite simulation? H correctly answers yes and aborts >>>>>>>> the simulation.
Nope, H is asked the question, does the machine represented by
your input finish running in finite time?
Does my exhaust system need to be replaced after you just replaced >>>>>> it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state when
run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you to be
a LIAR. NO ONE (except you) is interested in your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an input, whether the program will finish running, or continue to run forever.
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase
Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>> simulation of D that H itselfwould violate this requirement thus making this >>>>>>>>>>>>>>>>>>>>>>> choice necessarily<franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns "does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations available >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start
while (n is not a perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
On other days, he throws caution to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory things >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider do, is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Halting" the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, >>>>>>>>>>>>>>>>>>>>>>>>>>>> thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, which >>>>>>>>>>>>>>>>>>>>>>>>>> causes D(D) to Halt, the only correct answer >>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) should give is 1, so it is >>>>>>>>>>>>>>>>>>>>>>>>>> necessarily incorrect.
The easily verified fact that H itself would >>>>>>>>>>>>>>>>>>>>>>>>> not terminate unless it
aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report this >>>>>>>>>>>>>>>>>>>>>>>>> input as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to >>>>>>>>>>>>>>>>>>>>>>> not abort its simulation
correct. This also conclusively proves that its >>>>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally thus is correctly determined >>>>>>>>>>>>>>>>>>>>>>> to be non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite >>>>>>>>>>>>>>>>>>>>>> time, so it can't just be programmed to simulate >>>>>>>>>>>>>>>>>>>>>> forever. It also is required to return the correct >>>>>>>>>>>>>>>>>>>>>> answer,
never terminates normally that makes it necessarily >>>>>>>>>>>>>>>>>>>>> correct to do this.
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite awfully >>>>>>>>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so >>>>>>>>>>>>>>>>>> does the D, or does H not "Terminate Normally" and >>>>>>>>>>>>>>>>>> thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at >>>>>>>>>>>>>>>>> line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates >>>>>>>>>>>>>>>>> D(D) at line 03 ...
The simulated D cannot possibly terminate normally and >>>>>>>>>>>>>>>>> H will
never return to its caller unless and until H aborts >>>>>>>>>>>>>>>>> its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what >>>>>>>>>>>>> calls it.
We have two IDENTICAL initial sequence of instructions, >>>>>>>>>>>>>> the entry to H, in one case from main, and in the other >>>>>>>>>>>>>> from D, with identical parameters.
If the results follow different paths, there must be a >>>>>>>>>>>>>> first point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as >>>>>>>>>>>>> the inner
invocation. Directly executed H(D,D) always behaves exactly >>>>>>>>>>>>> the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have
answered YES, (1)
Because it is an easily verified fact that neither the >>>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever terminate >>>>>>>>>>>>> normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that itself >>>>>>>>>>>>> must halt.
No it DOES terminate because it DOES abort is simulation, >>>>>>>>>>>> since that is what the code says to do. No need to argue >>>>>>>>>>>> about a fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system. >>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust >>>>>>>>>>> system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust >>>>>>>>>>> system.
(f) At the checkout counter you accuse the head mechanic of >>>>>>>>>>> lying
because your car clearly does not need to have its >>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go >>>>>>>>>>> to jail.
H is asked the question: Does your input need to be aborted >>>>>>>>>>> to prevent infinite simulation? H correctly answers yes and >>>>>>>>>>> aborts the simulation.
Nope, H is asked the question, does the machine represented by >>>>>>>>>> your input finish running in finite time?
Does my exhaust system need to be replaced after you just
replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state
when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you to
be a LIAR. NO ONE (except you) is interested in your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to
run forever.
We can't say that D(D) halts on the basis that its otherwise infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you have
defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific
program. You H DOES abort at a specific point, and something that does
something different is a different program.
Maybe you just don't understand that a program is what it has actually
been programmed to be. Maybe you lost your job as a programmer because
you don't actually understand what a program is.
This is exactly the same thing as saying that the mechanic lied about
your car needing a new exhaust system because it doesn't need one after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does abort
its simulation?
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>> simulation of D that H itselfwould violate this requirement thus making this >>>>>>>>>>>>>>>>>>>>>>>> choice necessarilyOn Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "does not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start
while (n is not a perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
On other days, he throws caution to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider do, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is "Halting" the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> a decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
You know that it is necessarily true that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination >>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, which >>>>>>>>>>>>>>>>>>>>>>>>>>> causes D(D) to Halt, the only correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) should give is 1, so it is >>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily incorrect.
The easily verified fact that H itself would >>>>>>>>>>>>>>>>>>>>>>>>>> not terminate unless it
aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report this >>>>>>>>>>>>>>>>>>>>>>>>>> input as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to >>>>>>>>>>>>>>>>>>>>>>>> not abort its simulation
correct. This also conclusively proves that its >>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally thus is correctly determined >>>>>>>>>>>>>>>>>>>>>>>> to be non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite >>>>>>>>>>>>>>>>>>>>>>> time, so it can't just be programmed to simulate >>>>>>>>>>>>>>>>>>>>>>> forever. It also is required to return the >>>>>>>>>>>>>>>>>>>>>>> correct answer,
never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this.
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which point, so >>>>>>>>>>>>>>>>>>> does the D, or does H not "Terminate Normally" and >>>>>>>>>>>>>>>>>>> thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at >>>>>>>>>>>>>>>>>> line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates >>>>>>>>>>>>>>>>>> D(D) at line 03 ...
The simulated D cannot possibly terminate normally and >>>>>>>>>>>>>>>>>> H will
never return to its caller unless and until H aborts >>>>>>>>>>>>>>>>>> its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what >>>>>>>>>>>>>> calls it.
We have two IDENTICAL initial sequence of instructions, >>>>>>>>>>>>>>> the entry to H, in one case from main, and in the other >>>>>>>>>>>>>>> from D, with identical parameters.
If the results follow different paths, there must be a >>>>>>>>>>>>>>> first point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) >>>>>>>>>>>>>> as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have >>>>>>>>>>>>> answered YES, (1)
Because it is an easily verified fact that neither the >>>>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever terminate >>>>>>>>>>>>>> normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that itself >>>>>>>>>>>>>> must halt.
No it DOES terminate because it DOES abort is simulation, >>>>>>>>>>>>> since that is what the code says to do. No need to argue >>>>>>>>>>>>> about a fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system. >>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust >>>>>>>>>>>> system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust >>>>>>>>>>>> system.
(f) At the checkout counter you accuse the head mechanic of >>>>>>>>>>>> lying
because your car clearly does not need to have its >>>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or >>>>>>>>>>>> go to jail.
H is asked the question: Does your input need to be aborted >>>>>>>>>>>> to prevent infinite simulation? H correctly answers yes and >>>>>>>>>>>> aborts the simulation.
Nope, H is asked the question, does the machine represented >>>>>>>>>>> by your input finish running in finite time?
Does my exhaust system need to be replaced after you just
replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state
when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you
to be a LIAR. NO ONE (except you) is interested in your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue
to run forever.
We can't say that D(D) halts on the basis that its otherwise infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you have
defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific
program. You H DOES abort at a specific point, and something that
does something different is a different program.
Maybe you just don't understand that a program is what it has
actually been programmed to be. Maybe you lost your job as a
programmer because you don't actually understand what a program is.
This is exactly the same thing as saying that the mechanic lied about
your car needing a new exhaust system because it doesn't need one after >>>> it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does
abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES abort its simmulation and returns the value 0 to it.
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote:
Since it is true that unless H aborts its simulation >>>>>>>>>>>>>>>>>>> of D that H itselfOn 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase
would violate this requirement thus making this >>>>>>>>>>>>>>>>>>>>> choice necessarilyThe easily verified fact that H itself would not >>>>>>>>>>>>>>>>>>>>>>> terminate unless it<franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns "does >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations available >>>>>>>>>>>>>>>>>>>>>>>>>>>>> on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is concerned >>>>>>>>>>>>>>>>>>>>>>>>>>>>> about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful.
How would it know the correct answer? Will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number?)
On some days he will claim that he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>> never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled by >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple question >>>>>>>>>>>>>>>>>>>>>>>>>>>>> for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory things >>>>>>>>>>>>>>>>>>>>>>>>>>>>> days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take some >>>>>>>>>>>>>>>>>>>>>>>>>>>>> time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts."
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they >>>>>>>>>>>>>>>>>>>>>>>>>>>>> are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they >>>>>>>>>>>>>>>>>>>>>>>>>>>>> will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing context, >>>>>>>>>>>>>>>>>>>>>>>>>>> which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and the >>>>>>>>>>>>>>>>>>>>>>>>>>>> only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to compute, >>>>>>>>>>>>>>>>>>>>>>>>>>> if this is what ALL decider do, is "Halting" >>>>>>>>>>>>>>>>>>>>>>>>>>> the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the simulatiion >>>>>>>>>>>>>>>>>>>>>>>>>>> done by H, but by the machine that H is >>>>>>>>>>>>>>>>>>>>>>>>>>> TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>> after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the >>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly >>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>>>>>> invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>>>>>>> making the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, >>>>>>>>>>>>>>>>>>>>>>>> which since H(D,D) returns 0, which causes D(D) >>>>>>>>>>>>>>>>>>>>>>>> to Halt, the only correct answer that H(D,D) >>>>>>>>>>>>>>>>>>>>>>>> should give is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this >>>>>>>>>>>>>>>>>>>>>>> input as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to not >>>>>>>>>>>>>>>>>>>>> abort its simulation
correct. This also conclusively proves that its >>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally thus is correctly determined to >>>>>>>>>>>>>>>>>>>>> be non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite >>>>>>>>>>>>>>>>>>>> time, so it can't just be programmed to simulate >>>>>>>>>>>>>>>>>>>> forever. It also is required to return the correct >>>>>>>>>>>>>>>>>>>> answer,
never terminates normally that makes it necessarily >>>>>>>>>>>>>>>>>>> correct to do this.
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite awfully >>>>>>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does >>>>>>>>>>>>>>>> the D, or does H not "Terminate Normally" and thus isn't >>>>>>>>>>>>>>>> a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line >>>>>>>>>>>>>>> 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates >>>>>>>>>>>>>>> D(D) at line 03 ...
The simulated D cannot possibly terminate normally and H >>>>>>>>>>>>>>> will
never return to its caller unless and until H aborts its >>>>>>>>>>>>>>> simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what >>>>>>>>>>> calls it.
We have two IDENTICAL initial sequence of instructions, the >>>>>>>>>>>> entry to H, in one case from main, and in the other from D, >>>>>>>>>>>> with identical parameters.
If the results follow different paths, there must be a first >>>>>>>>>>>> point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as >>>>>>>>>>> the inner
invocation. Directly executed H(D,D) always behaves exactly >>>>>>>>>>> the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking >>>>>>>>>> H to decide if D(D) will Halt, it should have answered YES, (1) >>>>>>>>>>
Because it is an easily verified fact that neither the
directly executed
H(D,D) nor the directly executed D(D) would ever terminate >>>>>>>>>>> normally
unless H aborts its simulation of D, H is necessarily correct >>>>>>>>>>> to abort
its simulation of D to meet the requirement that itself must >>>>>>>>>>> halt.
No it DOES terminate because it DOES abort is simulation,
since that is what the code says to do. No need to argue about >>>>>>>>>> a fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system. >>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust
system.
(d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system. >>>>>>>>> (f) At the checkout counter you accuse the head mechanic of lying >>>>>>>>> because your car clearly does not need to have its exhaust >>>>>>>>> system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go >>>>>>>>> to jail.
H is asked the question: Does your input need to be aborted to >>>>>>>>> prevent infinite simulation? H correctly answers yes and
aborts the simulation.
Nope, H is asked the question, does the machine represented by >>>>>>>> your input finish running in finite time?
Does my exhaust system need to be replaced after you just
replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state when
run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you to
be a LIAR. NO ONE (except you) is interested in your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to run
forever.
We can't say that D(D) halts on the basis that its otherwise infinite simulation has already been aborted.
This is exactly the same thing as saying that the mechanic lied about
your car needing a new exhaust system because it doesn't need one after
it has been replaced.
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote:
On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote:
On 5/25/23 11:17 PM, olcott wrote:
On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote:
never terminates normally that makes it necessarily >>>>>>>>>>>>>>>>> correct to do this.On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote:
would violate this requirement thus making this >>>>>>>>>>>>>>>>>>> choice necessarilyOn 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>>>>> writes:
The easily verified fact that H itself would not >>>>>>>>>>>>>>>>>>>>> terminate unless it
On Wednesday, May 24, 2023 at 9:14:36 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns "does not >>>>>>>>>>>>>>>>>>>>>>>>>>> halt" for at least some
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start >>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>
halting computations (citations available on >>>>>>>>>>>>>>>>>>>>>>>>>>> request) so the result
tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is concerned >>>>>>>>>>>>>>>>>>>>>>>>>>> about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or the >>>>>>>>>>>>>>>>>>>>>>>>>>> general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful.
How would it know the correct answer? Will >>>>>>>>>>>>>>>>>>>>>>>>>>>> it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>> number?)
On some days he will claim that he has never >>>>>>>>>>>>>>>>>>>>>>>>>>> said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled by the >>>>>>>>>>>>>>>>>>>>>>>>>>> "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply declares >>>>>>>>>>>>>>>>>>>>>>>>>>> that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to the wind >>>>>>>>>>>>>>>>>>>>>>>>>>> and claims the general
case, but again with the set of non-halting >>>>>>>>>>>>>>>>>>>>>>>>>>> computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple question >>>>>>>>>>>>>>>>>>>>>>>>>>> for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory things >>>>>>>>>>>>>>>>>>>>>>>>>>> days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take some >>>>>>>>>>>>>>>>>>>>>>>>>>> time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts."
in reply to the question "do you still assert >>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P) == false is
the 'correct' answer even though P(P) halts?" >>>>>>>>>>>>>>>>>>>>>>>>>>> I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not point in >>>>>>>>>>>>>>>>>>>>>>>>>>> saying anything else.
The one weapon we have against cranks is that >>>>>>>>>>>>>>>>>>>>>>>>>>> most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why they are >>>>>>>>>>>>>>>>>>>>>>>>>>> usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they will >>>>>>>>>>>>>>>>>>>>>>>>>>> have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of being >>>>>>>>>>>>>>>>>>>>>>>>>>> clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity.
Ben has already agreed that H does correctly >>>>>>>>>>>>>>>>>>>>>>>>>> determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser approved >>>>>>>>>>>>>>>>>>>>>>>>>> criteria. (see quote
below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing context, >>>>>>>>>>>>>>>>>>>>>>>>> which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that he >>>>>>>>>>>>>>>>>>>>>>>> agreed that H does
correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the mapping >>>>>>>>>>>>>>>>>>>>>>>>>> *from their inputs* toSO, what mapping is this supposed to compute, >>>>>>>>>>>>>>>>>>>>>>>>> if this is what ALL decider do, is "Halting" >>>>>>>>>>>>>>>>>>>>>>>>> the only type of decider?
their own accept or reject state and the only >>>>>>>>>>>>>>>>>>>>>>>>>> objection to my proof is
that it does not get the same result as a >>>>>>>>>>>>>>>>>>>>>>>>>> non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by tautology* >>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the MACHINE >>>>>>>>>>>>>>>>>>>>>>>>> coming to a final state, and it does. >>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from the probem. >>>>>>>>>>>>>>>>>>>>>>>>> It isn't asking about the simulatiion done by >>>>>>>>>>>>>>>>>>>>>>>>> H, but by the machine that H is TRYING to >>>>>>>>>>>>>>>>>>>>>>>>> simulate (but can't).
My reviewers insist on staying one recursive >>>>>>>>>>>>>>>>>>>>>>>>>> invocation away from
reality. H does correctly determine that D >>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior after >>>>>>>>>>>>>>>>>>>>>>>>>> H has already made this
correct halt status decision, thus are clearly >>>>>>>>>>>>>>>>>>>>>>>>>> out-of-sync by one
recursive invocation.
Because it makes the WRONG decision by the >>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem, what does the >>>>>>>>>>>>>>>>>>>>>>>>> machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of a >>>>>>>>>>>>>>>>>>>>>>>> decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the outer >>>>>>>>>>>>>>>>>>>>>>>> invocation halts only
because the inner invocation was correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that no >>>>>>>>>>>>>>>>>>>>>>>> invocation would ever halt
unless the inner invocation was aborted, thus >>>>>>>>>>>>>>>>>>>>>>>> making the termination of
this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated
by the requirements that a halt decider must >>>>>>>>>>>>>>>>>>>>>>> always halt, thus
conclusively proving that this termination is >>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
It is also mandated to give the correct answer, >>>>>>>>>>>>>>>>>>>>>> which since H(D,D) returns 0, which causes D(D) to >>>>>>>>>>>>>>>>>>>>>> Halt, the only correct answer that H(D,D) should >>>>>>>>>>>>>>>>>>>>>> give is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>
aborted the simulation of its input conclusively >>>>>>>>>>>>>>>>>>>>> proves that H is
necessarily correct to do this and report this >>>>>>>>>>>>>>>>>>>>> input as non-halting.
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to not >>>>>>>>>>>>>>>>>>> abort its simulation
correct. This also conclusively proves that its input >>>>>>>>>>>>>>>>>>> cannot possibly
terminate normally thus is correctly determined to be >>>>>>>>>>>>>>>>>>> non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite time, >>>>>>>>>>>>>>>>>> so it can't just be programmed to simulate forever. It >>>>>>>>>>>>>>>>>> also is required to return the correct answer, >>>>>>>>>>>>>>>>> Since it is true that unless H aborts its simulation of >>>>>>>>>>>>>>>>> D that H itself
So, you are admitting that H doesn't actually "terminate >>>>>>>>>>>>>>>> normally" and thus fails to be a decider?
Your software engineering skill must be quite awfully >>>>>>>>>>>>>>> terrible to make a mistake like that.
So, does H "Terminate Normally", at which point, so does >>>>>>>>>>>>>> the D, or does H not "Terminate Normally" and thus isn't a >>>>>>>>>>>>>> decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at line 03 >>>>>>>>>>>>> ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that simulates D(D) >>>>>>>>>>>>> at line 03 ...
The simulated D cannot possibly terminate normally and H will >>>>>>>>>>>>> never return to its caller unless and until H aborts its >>>>>>>>>>>>> simulation.
So, why doesn't that happen when main calls H?
H does return to its caller when main calls H.
So, which instruction acts differently?
H(D,D) always operates the exact same way no matter what calls it. >>>>>>>>>
We have two IDENTICAL initial sequence of instructions, the >>>>>>>>>> entry to H, in one case from main, and in the other from D, >>>>>>>>>> with identical parameters.
If the results follow different paths, there must be a first >>>>>>>>>> point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) as the >>>>>>>>> inner
invocation. Directly executed H(D,D) always behaves exactly the >>>>>>>>> same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is asking H >>>>>>>> to decide if D(D) will Halt, it should have answered YES, (1)
No it DOES terminate because it DOES abort is simulation, since >>>>>>>> that is what the code says to do. No need to argue about a
Because it is an easily verified fact that neither the directly >>>>>>>>> executed
H(D,D) nor the directly executed D(D) would ever terminate
normally
unless H aborts its simulation of D, H is necessarily correct >>>>>>>>> to abort
its simulation of D to meet the requirement that itself must halt. >>>>>>>>
fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system.
(c) You ask the head mechanic to inspect your car's exhaust system. >>>>>>> (d) The head mechanic tells you it needs to be replaced.
(e) You authorize the head mechanic to replace the exhaust system. >>>>>>> (f) At the checkout counter you accuse the head mechanic of lying >>>>>>> because your car clearly does not need to have its exhaust >>>>>>> system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or go to >>>>>>> jail.
H is asked the question: Does your input need to be aborted to
prevent infinite simulation? H correctly answers yes and aborts >>>>>>> the simulation.
Nope, H is asked the question, does the machine represented by
your input finish running in finite time?
Does my exhaust system need to be replaced after you just replaced it? >>>>>
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
We can't say that that answer is wrong on the basis of the
behavior of D after the input to H has been aborted.
*A different context makes it a different question*
You are just working with the strawman built out of the straw in your
brain.
You keep repeating that error and ducking the question you can not
answer because you are just lying about what you are doing.
Is proven to be incorrect on the basis of after
(a) The exhaust system has been replaced.
(b) The simulation of the input has been aborted.
The answer to the original question becomes NO.
WRONG, the question was NEVER about H's simulation, but about the
behavior of the machine described.
You changed the spark plugs instead of the exhaust system.
The answer to the question:
Is it possible for D correctly simulated by H to terminate normally?
Competent and honest software engineers concur
But that isn't the question, showing you are a liar.
Show a reliable source, not you, that says a Halt Decider needs to
answer the question the way you are asking.
Remember, if H stops its simulation, it isn't a UTM, so a question
about UTM simulation isn't asking about H's simulation.
You can't, because everything you have done is based on LIES.
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote:So, which instruction acts differently?
On 5/26/23 1:06 AM, olcott wrote:
On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itselfwould violate this requirement thus making this >>>>>>>>>>>>>>>>>>>>>>>>> choice necessarilyOn Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "does not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start
while (n is not a perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number) {
n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is currently >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sitting, you can't use his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
On other days, he throws caution to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider do, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is "Halting" the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H is TRYING to simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of the problem, what does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> referring to contradicts the definition of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a decider that must compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
You know that it is necessarily true that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this termination >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, which >>>>>>>>>>>>>>>>>>>>>>>>>>>> causes D(D) to Halt, the only correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) should give is 1, so it is >>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily incorrect.
The easily verified fact that H itself would >>>>>>>>>>>>>>>>>>>>>>>>>>> not terminate unless it
aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report >>>>>>>>>>>>>>>>>>>>>>>>>>> this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz Turing >>>>>>>>>>>>>>>>>>>>>>>>>>> machine based halting
problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice to >>>>>>>>>>>>>>>>>>>>>>>>> not abort its simulation
correct. This also conclusively proves that its >>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally thus is correctly determined >>>>>>>>>>>>>>>>>>>>>>>>> to be non-halting.
So? You still don't get it.
yes, it is required to give an answer in finite >>>>>>>>>>>>>>>>>>>>>>>> time, so it can't just be programmed to simulate >>>>>>>>>>>>>>>>>>>>>>>> forever. It also is required to return the >>>>>>>>>>>>>>>>>>>>>>>> correct answer,
never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this.
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which point, so >>>>>>>>>>>>>>>>>>>> does the D, or does H not "Terminate Normally" and >>>>>>>>>>>>>>>>>>>> thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at >>>>>>>>>>>>>>>>>>> line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ...
The simulated D cannot possibly terminate normally >>>>>>>>>>>>>>>>>>> and H will
never return to its caller unless and until H aborts >>>>>>>>>>>>>>>>>>> its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter what >>>>>>>>>>>>>>> calls it.
We have two IDENTICAL initial sequence of instructions, >>>>>>>>>>>>>>>> the entry to H, in one case from main, and in the other >>>>>>>>>>>>>>>> from D, with identical parameters.
If the results follow different paths, there must be a >>>>>>>>>>>>>>>> first point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) >>>>>>>>>>>>>>> as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have >>>>>>>>>>>>>> answered YES, (1)
Because it is an easily verified fact that neither the >>>>>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that itself >>>>>>>>>>>>>>> must halt.
No it DOES terminate because it DOES abort is simulation, >>>>>>>>>>>>>> since that is what the code says to do. No need to argue >>>>>>>>>>>>>> about a fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system. >>>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust >>>>>>>>>>>>> system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust >>>>>>>>>>>>> system.
(f) At the checkout counter you accuse the head mechanic of >>>>>>>>>>>>> lying
because your car clearly does not need to have its >>>>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or >>>>>>>>>>>>> go to jail.
H is asked the question: Does your input need to be aborted >>>>>>>>>>>>> to prevent infinite simulation? H correctly answers yes >>>>>>>>>>>>> and aborts the simulation.
Nope, H is asked the question, does the machine represented >>>>>>>>>>>> by your input finish running in finite time?
Does my exhaust system need to be replaced after you just >>>>>>>>>>> replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state >>>>>>>> when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced* >>>>>>>
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you
to be a LIAR. NO ONE (except you) is interested in your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue >>>>>> to run forever.
We can't say that D(D) halts on the basis that its otherwise infinite >>>>> simulation has already been aborted.
No, we say it halts because when we run it with the H that you have
defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific
program. You H DOES abort at a specific point, and something that
does something different is a different program.
Maybe you just don't understand that a program is what it has
actually been programmed to be. Maybe you lost your job as a
programmer because you don't actually understand what a program is.
This is exactly the same thing as saying that the mechanic lied about >>>>> your car needing a new exhaust system because it doesn't need one
after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it halt. >>>>
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does
abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES abort its
simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation does
D(D) ever terminate normally?
On 5/26/23 10:06 PM, olcott wrote:
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote:
On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/26/23 1:06 AM, olcott wrote:So, which instruction acts differently?
On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote:
On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a decider? >>>>>>>>>>>>>>>>>>>>>>>Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itselfcorrect. This also conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>> its input cannot possiblyThe easily verified fact that H itself would >>>>>>>>>>>>>>>>>>>>>>>>>>>> not terminate unless it >>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report >>>>>>>>>>>>>>>>>>>>>>>>>>>> this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>On Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "does not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start
while (n is not a perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently sitting, you can't use his H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for
anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be fooled >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you still >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider do, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is "Halting" the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine that H is TRYING to simulate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (but can't).
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of the problem, what does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine represented by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are referring to contradicts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a decider that must compute >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this termination >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>> causes D(D) to Halt, the only correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer that H(D,D) should give is 1, so it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine based halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice >>>>>>>>>>>>>>>>>>>>>>>>>> to not abort its simulation >>>>>>>>>>>>>>>>>>>>>>>>>> would violate this requirement thus making >>>>>>>>>>>>>>>>>>>>>>>>>> this choice necessarily
terminate normally thus is correctly >>>>>>>>>>>>>>>>>>>>>>>>>> determined to be non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>
So? You still don't get it.
yes, it is required to give an answer in finite >>>>>>>>>>>>>>>>>>>>>>>>> time, so it can't just be programmed to >>>>>>>>>>>>>>>>>>>>>>>>> simulate forever. It also is required to return >>>>>>>>>>>>>>>>>>>>>>>>> the correct answer,
never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this. >>>>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which point, so >>>>>>>>>>>>>>>>>>>>> does the D, or does H not "Terminate Normally" and >>>>>>>>>>>>>>>>>>>>> thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at >>>>>>>>>>>>>>>>>>>> line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ...
The simulated D cannot possibly terminate normally >>>>>>>>>>>>>>>>>>>> and H will
never return to its caller unless and until H aborts >>>>>>>>>>>>>>>>>>>> its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter what >>>>>>>>>>>>>>>> calls it.
We have two IDENTICAL initial sequence of instructions, >>>>>>>>>>>>>>>>> the entry to H, in one case from main, and in the other >>>>>>>>>>>>>>>>> from D, with identical parameters.
If the results follow different paths, there must be a >>>>>>>>>>>>>>>>> first point of departure. What is it.
D(D) is merely the outer invocation that includes H(D,D) >>>>>>>>>>>>>>>> as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have >>>>>>>>>>>>>>> answered YES, (1)
Because it is an easily verified fact that neither the >>>>>>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that itself >>>>>>>>>>>>>>>> must halt.
No it DOES terminate because it DOES abort is simulation, >>>>>>>>>>>>>>> since that is what the code says to do. No need to argue >>>>>>>>>>>>>>> about a fantasy case that doesn't exist.
*Halting auto problem repair shop analogy*
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust system. >>>>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's >>>>>>>>>>>>>> exhaust system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust >>>>>>>>>>>>>> system.
(f) At the checkout counter you accuse the head mechanic >>>>>>>>>>>>>> of lying
because your car clearly does not need to have its >>>>>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up or >>>>>>>>>>>>>> go to jail.
H is asked the question: Does your input need to be >>>>>>>>>>>>>> aborted to prevent infinite simulation? H correctly >>>>>>>>>>>>>> answers yes and aborts the simulation.
Nope, H is asked the question, does the machine represented >>>>>>>>>>>>> by your input finish running in finite time?
Does my exhaust system need to be replaced after you just >>>>>>>>>>>> replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state >>>>>>>>> when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the
answer changes to NO *After the exhaust system has been replaced* >>>>>>>>
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows you >>>>>>> to be a LIAR. NO ONE (except you) is interested in your question. >>>>>>>
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program >>>>>>> and an input, whether the program will finish running, or
continue to run forever.
We can't say that D(D) halts on the basis that its otherwise infinite >>>>>> simulation has already been aborted.
No, we say it halts because when we run it with the H that you have
defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific
program. You H DOES abort at a specific point, and something that
does something different is a different program.
Maybe you just don't understand that a program is what it has
actually been programmed to be. Maybe you lost your job as a
programmer because you don't actually understand what a program is.
This is exactly the same thing as saying that the mechanic lied about >>>>>> your car needing a new exhaust system because it doesn't need one
after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it halt. >>>>>
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does
abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES abort
its simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation does
D(D) ever terminate normally?
No, but in that Hypothetical case H(D,D) never gives an answer so fails
too.
On 5/27/2023 7:12 AM, Richard Damon wrote:
On 5/26/23 10:06 PM, olcott wrote:
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:*Halting auto problem repair shop analogy*
On 5/26/2023 10:33 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/26/23 1:06 AM, olcott wrote:So, which instruction acts differently?
On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a >>>>>>>>>>>>>>>>>>>>>>>> decider?Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itself >>>>>>>>>>>>>>>>>>>>>>>>> never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this. >>>>>>>>>>>>>>>>>>>>>>>>correct. This also conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>> its input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally thus is correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> determined to be non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>The easily verified fact that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>> would not terminate unless it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "does not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = start
while (n is not a perfect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently sitting, you can't use his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H for
anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fooled by the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> still assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though P(P) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against cranks >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that most can't bear to retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at every >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status of D >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> according to the Sisper approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as a non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology*
SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, is "Halting" the only type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does.
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine that H is TRYING to simulate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of the problem, what >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does the machine represented by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input do?
My reviewers only focus on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are referring to contradicts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a decider that must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was aborted, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which causes D(D) to Halt, the only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer that H(D,D) should give is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine based halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice >>>>>>>>>>>>>>>>>>>>>>>>>>> to not abort its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>> would violate this requirement thus making >>>>>>>>>>>>>>>>>>>>>>>>>>> this choice necessarily
So? You still don't get it. >>>>>>>>>>>>>>>>>>>>>>>>>>
yes, it is required to give an answer in >>>>>>>>>>>>>>>>>>>>>>>>>> finite time, so it can't just be programmed to >>>>>>>>>>>>>>>>>>>>>>>>>> simulate forever. It also is required to >>>>>>>>>>>>>>>>>>>>>>>>>> return the correct answer,
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which point, >>>>>>>>>>>>>>>>>>>>>> so does the D, or does H not "Terminate Normally" >>>>>>>>>>>>>>>>>>>>>> and thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) at >>>>>>>>>>>>>>>>>>>>> line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ...
The simulated D cannot possibly terminate normally >>>>>>>>>>>>>>>>>>>>> and H will
never return to its caller unless and until H >>>>>>>>>>>>>>>>>>>>> aborts its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter >>>>>>>>>>>>>>>>> what calls it.
We have two IDENTICAL initial sequence of
instructions, the entry to H, in one case from main, >>>>>>>>>>>>>>>>>> and in the other from D, with identical parameters. >>>>>>>>>>>>>>>>>>
If the results follow different paths, there must be a >>>>>>>>>>>>>>>>>> first point of departure. What is it.
D(D) is merely the outer invocation that includes >>>>>>>>>>>>>>>>> H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have >>>>>>>>>>>>>>>> answered YES, (1)
Because it is an easily verified fact that neither the >>>>>>>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that itself >>>>>>>>>>>>>>>>> must halt.
No it DOES terminate because it DOES abort is
simulation, since that is what the code says to do. No >>>>>>>>>>>>>>>> need to argue about a fantasy case that doesn't exist. >>>>>>>>>>>>>>>
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust >>>>>>>>>>>>>>> system.
(c) You ask the head mechanic to inspect your car's >>>>>>>>>>>>>>> exhaust system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the >>>>>>>>>>>>>>> exhaust system.
(f) At the checkout counter you accuse the head mechanic >>>>>>>>>>>>>>> of lying
because your car clearly does not need to have its >>>>>>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up >>>>>>>>>>>>>>> or go to jail.
H is asked the question: Does your input need to be >>>>>>>>>>>>>>> aborted to prevent infinite simulation? H correctly >>>>>>>>>>>>>>> answers yes and aborts the simulation.
Nope, H is asked the question, does the machine
represented by your input finish running in finite time? >>>>>>>>>>>>>>
Does my exhaust system need to be replaced after you just >>>>>>>>>>>>> replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final state >>>>>>>>>> when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the >>>>>>>>> answer changes to NO *After the exhaust system has been replaced* >>>>>>>>>
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows
you to be a LIAR. NO ONE (except you) is interested in your
question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of >>>>>>>> determining, from a description of an arbitrary computer program >>>>>>>> and an input, whether the program will finish running, or
continue to run forever.
We can't say that D(D) halts on the basis that its otherwise
infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you
have defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific
program. You H DOES abort at a specific point, and something that
does something different is a different program.
Maybe you just don't understand that a program is what it has
actually been programmed to be. Maybe you lost your job as a
programmer because you don't actually understand what a program is. >>>>>>
This is exactly the same thing as saying that the mechanic lied
about
your car needing a new exhaust system because it doesn't need one >>>>>>> after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it
halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does
abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES abort
its simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation does
D(D) ever terminate normally?
No, but in that Hypothetical case H(D,D) never gives an answer so
fails too.
Do you understand that when D correctly simulated by H has had
its simulation aborted by H that this does not count as normal
termination for D?
On 5/27/23 11:59 AM, olcott wrote:*We must be otherwise H gets stuck in recursive simulation*
On 5/27/2023 7:12 AM, Richard Damon wrote:
On 5/26/23 10:06 PM, olcott wrote:
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question:
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote:
On 5/26/23 12:17 PM, olcott wrote:*Halting auto problem repair shop analogy*
On 5/26/2023 10:33 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/26/23 1:06 AM, olcott wrote:So, which instruction acts differently?
On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a >>>>>>>>>>>>>>>>>>>>>>>>> decider?The easily verified fact that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would not terminate unless it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "does not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n = >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect
number) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently sitting, you can't use his >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H for
anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? Will it ever return an answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fooled by the "usual construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can take >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> still assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cranks is that most can't bear to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D according to the Sisper approved >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria.
Because all deciders only compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as a non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tautology* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, is "Halting" the only type of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider?
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does.
Except YOU are one invocation from the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine that H is TRYING to simulate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of the problem, what >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does the machine represented by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input do?
My reviewers only focus on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are referring to contradicts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a decider that must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted, thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which causes D(D) to Halt, the only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer that H(D,D) should give is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine based halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the choice >>>>>>>>>>>>>>>>>>>>>>>>>>>> to not abort its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>> would violate this requirement thus making >>>>>>>>>>>>>>>>>>>>>>>>>>>> this choice necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This also conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>> its input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally thus is correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> determined to be non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? You still don't get it. >>>>>>>>>>>>>>>>>>>>>>>>>>>
yes, it is required to give an answer in >>>>>>>>>>>>>>>>>>>>>>>>>>> finite time, so it can't just be programmed >>>>>>>>>>>>>>>>>>>>>>>>>>> to simulate forever. It also is required to >>>>>>>>>>>>>>>>>>>>>>>>>>> return the correct answer, >>>>>>>>>>>>>>>>>>>>>>>>>> Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itself >>>>>>>>>>>>>>>>>>>>>>>>>> never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this. >>>>>>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which point, >>>>>>>>>>>>>>>>>>>>>>> so does the D, or does H not "Terminate Normally" >>>>>>>>>>>>>>>>>>>>>>> and thus isn't a decider?
// The following is written in C
01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) >>>>>>>>>>>>>>>>>>>>>> at line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ...
The simulated D cannot possibly terminate normally >>>>>>>>>>>>>>>>>>>>>> and H will
never return to its caller unless and until H >>>>>>>>>>>>>>>>>>>>>> aborts its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter >>>>>>>>>>>>>>>>>> what calls it.
We have two IDENTICAL initial sequence of >>>>>>>>>>>>>>>>>>> instructions, the entry to H, in one case from main, >>>>>>>>>>>>>>>>>>> and in the other from D, with identical parameters. >>>>>>>>>>>>>>>>>>>
If the results follow different paths, there must be >>>>>>>>>>>>>>>>>>> a first point of departure. What is it.
D(D) is merely the outer invocation that includes >>>>>>>>>>>>>>>>>> H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have >>>>>>>>>>>>>>>>> answered YES, (1)
Because it is an easily verified fact that neither the >>>>>>>>>>>>>>>>>> directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that >>>>>>>>>>>>>>>>>> itself must halt.
No it DOES terminate because it DOES abort is >>>>>>>>>>>>>>>>> simulation, since that is what the code says to do. No >>>>>>>>>>>>>>>>> need to argue about a fantasy case that doesn't exist. >>>>>>>>>>>>>>>>
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust >>>>>>>>>>>>>>>> system.
(c) You ask the head mechanic to inspect your car's >>>>>>>>>>>>>>>> exhaust system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the >>>>>>>>>>>>>>>> exhaust system.
(f) At the checkout counter you accuse the head mechanic >>>>>>>>>>>>>>>> of lying
because your car clearly does not need to have its >>>>>>>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up >>>>>>>>>>>>>>>> or go to jail.
H is asked the question: Does your input need to be >>>>>>>>>>>>>>>> aborted to prevent infinite simulation? H correctly >>>>>>>>>>>>>>>> answers yes and aborts the simulation.
Nope, H is asked the question, does the machine
represented by your input finish running in finite time? >>>>>>>>>>>>>>>
Does my exhaust system need to be replaced after you just >>>>>>>>>>>>>> replaced it?
Why do you say that?
(a) Does the exhaust system need to be replaced?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final >>>>>>>>>>> state when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced?
has YES as a correct answer.
We can't say that this answer is wrong on the basis that the >>>>>>>>>> answer changes to NO *After the exhaust system has been replaced* >>>>>>>>>>
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows >>>>>>>>> you to be a LIAR. NO ONE (except you) is interested in your
question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of >>>>>>>>> determining, from a description of an arbitrary computer
program and an input, whether the program will finish running, >>>>>>>>> or continue to run forever.
We can't say that D(D) halts on the basis that its otherwise
infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you
have defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific >>>>>>> program. You H DOES abort at a specific point, and something that >>>>>>> does something different is a different program.
Maybe you just don't understand that a program is what it has
actually been programmed to be. Maybe you lost your job as a
programmer because you don't actually understand what a program is. >>>>>>>
This is exactly the same thing as saying that the mechanic lied >>>>>>>> about
your car needing a new exhaust system because it doesn't need
one after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it >>>>>>> halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does
abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES abort
its simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation does >>>> D(D) ever terminate normally?
No, but in that Hypothetical case H(D,D) never gives an answer so
fails too.
Do you understand that when D correctly simulated by H has had
its simulation aborted by H that this does not count as normal
termination for D?
Right, but we aren't asked about D simulated by H,
On 5/27/2023 12:19 PM, Richard Damon wrote:
On 5/27/23 11:59 AM, olcott wrote:*We must be otherwise H gets stuck in recursive simulation*
On 5/27/2023 7:12 AM, Richard Damon wrote:
On 5/26/23 10:06 PM, olcott wrote:
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question: >>>>>>>>>>>>> (a) Does the exhaust system need to be replaced?
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/26/23 12:17 PM, olcott wrote:
*Halting auto problem repair shop analogy*On 5/26/2023 10:33 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/26/23 1:06 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:So, which instruction acts differently? >>>>>>>>>>>>>>>>>>>>
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a >>>>>>>>>>>>>>>>>>>>>>>>>> decider?The easily verified fact that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would not terminate unless it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and report >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H returns >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "does not halt" for at least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n =
start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a perfect
number) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
What would Olcott's "simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or the general case, but regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently sitting, you can't use >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? Will it ever return an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fooled by the "usual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he simply >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> declares that H(H^, H^) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an honest >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputant, because he will avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> take some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> still assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cranks is that most can't bear to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is why >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the mistake >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of being clear, we should pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the Sipser >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D according to the Sisper approved >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria.
Because all deciders only compute >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as a non-input this only objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by tautology* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, is "Halting" the only type of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the probem. It isn't asking about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatiion done by H, but by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine that H is TRYING to simulate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the definition of the problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what does the machine represented by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are referring to contradicts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a decider that must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
AN INPUT
to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted, thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
I have better words. The termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which causes D(D) to Halt, the only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer that H(D,D) should give >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine based halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> choice to not abort its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> would violate this requirement thus making >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this choice necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This also conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally thus is correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined to be non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? You still don't get it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
yes, it is required to give an answer in >>>>>>>>>>>>>>>>>>>>>>>>>>>> finite time, so it can't just be programmed >>>>>>>>>>>>>>>>>>>>>>>>>>>> to simulate forever. It also is required to >>>>>>>>>>>>>>>>>>>>>>>>>>>> return the correct answer, >>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>> never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this. >>>>>>>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which point, >>>>>>>>>>>>>>>>>>>>>>>> so does the D, or does H not "Terminate >>>>>>>>>>>>>>>>>>>>>>>> Normally" and thus isn't a decider? >>>>>>>>>>>>>>>>>>>>>>>>
// The following is written in C >>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11
executed D(D) invokes H(D,D) that simulates D(D) >>>>>>>>>>>>>>>>>>>>>>> at line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ...
The simulated D cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>> normally and H will
never return to its caller unless and until H >>>>>>>>>>>>>>>>>>>>>>> aborts its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter >>>>>>>>>>>>>>>>>>> what calls it.
We have two IDENTICAL initial sequence of >>>>>>>>>>>>>>>>>>>> instructions, the entry to H, in one case from main, >>>>>>>>>>>>>>>>>>>> and in the other from D, with identical parameters. >>>>>>>>>>>>>>>>>>>>
If the results follow different paths, there must be >>>>>>>>>>>>>>>>>>>> a first point of departure. What is it. >>>>>>>>>>>>>>>>>>>>
D(D) is merely the outer invocation that includes >>>>>>>>>>>>>>>>>>> H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) is >>>>>>>>>>>>>>>>>> asking H to decide if D(D) will Halt, it should have >>>>>>>>>>>>>>>>>> answered YES, (1)
Because it is an easily verified fact that neither >>>>>>>>>>>>>>>>>>> the directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is necessarily >>>>>>>>>>>>>>>>>>> correct to abort
its simulation of D to meet the requirement that >>>>>>>>>>>>>>>>>>> itself must halt.
No it DOES terminate because it DOES abort is >>>>>>>>>>>>>>>>>> simulation, since that is what the code says to do. No >>>>>>>>>>>>>>>>>> need to argue about a fantasy case that doesn't exist. >>>>>>>>>>>>>>>>>
(a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust >>>>>>>>>>>>>>>>> system.
(c) You ask the head mechanic to inspect your car's >>>>>>>>>>>>>>>>> exhaust system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the >>>>>>>>>>>>>>>>> exhaust system.
(f) At the checkout counter you accuse the head >>>>>>>>>>>>>>>>> mechanic of lying
because your car clearly does not need to have its >>>>>>>>>>>>>>>>> exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay up >>>>>>>>>>>>>>>>> or go to jail.
H is asked the question: Does your input need to be >>>>>>>>>>>>>>>>> aborted to prevent infinite simulation? H correctly >>>>>>>>>>>>>>>>> answers yes and aborts the simulation.
Nope, H is asked the question, does the machine >>>>>>>>>>>>>>>> represented by your input finish running in finite time? >>>>>>>>>>>>>>>>
Does my exhaust system need to be replaced after you just >>>>>>>>>>>>>>> replaced it?
Why do you say that?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final >>>>>>>>>>>> state when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced? >>>>>>>>>>> has YES as a correct answer.
We can't say that this answer is wrong on the basis that the >>>>>>>>>>> answer changes to NO *After the exhaust system has been
replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows >>>>>>>>>> you to be a LIAR. NO ONE (except you) is interested in your >>>>>>>>>> question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of >>>>>>>>>> determining, from a description of an arbitrary computer
program and an input, whether the program will finish running, >>>>>>>>>> or continue to run forever.
We can't say that D(D) halts on the basis that its otherwise >>>>>>>>> infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you >>>>>>>> have defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a specific >>>>>>>> program. You H DOES abort at a specific point, and something
that does something different is a different program.
Maybe you just don't understand that a program is what it has
actually been programmed to be. Maybe you lost your job as a
programmer because you don't actually understand what a program is. >>>>>>>>
This is exactly the same thing as saying that the mechanic lied >>>>>>>>> about
your car needing a new exhaust system because it doesn't need >>>>>>>>> one after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes it >>>>>>>> halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) does >>>>>>> abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES abort >>>>>> its simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation does >>>>> D(D) ever terminate normally?
No, but in that Hypothetical case H(D,D) never gives an answer so
fails too.
Do you understand that when D correctly simulated by H has had
its simulation aborted by H that this does not count as normal
termination for D?
Right, but we aren't asked about D simulated by H,
If H does not respond to the actual behavior of the simulated D then H
itself gets stuck in recursive simulation because it never aborts the simulation of its input.
*First element of formal proof*
Simulation invariant:
D correctly simulated by H cannot possibly reach its own line 04.
On 5/27/23 1:45 PM, olcott wrote:H getting stuck proves that you are out-of-sync with reality by one
On 5/27/2023 12:19 PM, Richard Damon wrote:
On 5/27/23 11:59 AM, olcott wrote:*We must be otherwise H gets stuck in recursive simulation*
On 5/27/2023 7:12 AM, Richard Damon wrote:
On 5/26/23 10:06 PM, olcott wrote:
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question: >>>>>>>>>>>>>> (a) Does the exhaust system need to be replaced?
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/26/23 11:07 AM, olcott wrote:
On 5/26/2023 9:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/26/23 1:06 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:So, which instruction acts differently? >>>>>>>>>>>>>>>>>>>>>
So, you are admitting that H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>>> "terminate normally" and thus fails to be a >>>>>>>>>>>>>>>>>>>>>>>>>>> decider?The easily verified fact that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would not terminate unless it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns "does not halt" for at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
arbitrarily long int n =
start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
What would Olcott's "simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or the general case, but >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently sitting, you can't use >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How would it know the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? Will it ever return an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On some days he will claim that he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has never said he has a general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fooled by the "usual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply declares that H(H^, H^) == >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest disputant, because he will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question for years (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say contradictory >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things days apart (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> take some time to clear all the smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he has >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> still assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts?" I don't see any point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cranks is that most can't bear to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> why they are usually so evasive about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they know >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they will have to stick with them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake of being clear, we should >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sipser approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a tautology thus necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of D according to the Sisper approved >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> result as a non-input this only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by tautology* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>SO, what mapping is this supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute, if this is what ALL decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, is "Halting" the only type of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the probem. It isn't asking about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulatiion done by H, but by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine that H is TRYING to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly determine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that D correctly simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the definition of the problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what does the machine represented by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior after H has already made this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are referring to contradicts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a decider that must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted, thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which since H(D,D) returns 0, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which causes D(D) to Halt, the only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer that H(D,D) should give >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is 1, so it is necessarily incorrect. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine based halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> choice to not abort its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would violate this requirement thus making >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this choice necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This also conclusively proves >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally thus is correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined to be non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? You still don't get it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
yes, it is required to give an answer in >>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite time, so it can't just be programmed >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to simulate forever. It also is required to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> return the correct answer, >>>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>> never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which >>>>>>>>>>>>>>>>>>>>>>>>> point, so does the D, or does H not "Terminate >>>>>>>>>>>>>>>>>>>>>>>>> Normally" and thus isn't a decider? >>>>>>>>>>>>>>>>>>>>>>>>>
// The following is written in C >>>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11 >>>>>>>>>>>>>>>>>>>>>>>> executed D(D) invokes H(D,D) that simulates D(D) >>>>>>>>>>>>>>>>>>>>>>>> at line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ...
The simulated D cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>> normally and H will
never return to its caller unless and until H >>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter >>>>>>>>>>>>>>>>>>>> what calls it.
We have two IDENTICAL initial sequence of >>>>>>>>>>>>>>>>>>>>> instructions, the entry to H, in one case from >>>>>>>>>>>>>>>>>>>>> main, and in the other from D, with identical >>>>>>>>>>>>>>>>>>>>> parameters.
If the results follow different paths, there must >>>>>>>>>>>>>>>>>>>>> be a first point of departure. What is it. >>>>>>>>>>>>>>>>>>>>>
D(D) is merely the outer invocation that includes >>>>>>>>>>>>>>>>>>>> H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) >>>>>>>>>>>>>>>>>>> is asking H to decide if D(D) will Halt, it should >>>>>>>>>>>>>>>>>>> have answered YES, (1)
Because it is an easily verified fact that neither >>>>>>>>>>>>>>>>>>>> the directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is >>>>>>>>>>>>>>>>>>>> necessarily correct to abort
its simulation of D to meet the requirement that >>>>>>>>>>>>>>>>>>>> itself must halt.
No it DOES terminate because it DOES abort is >>>>>>>>>>>>>>>>>>> simulation, since that is what the code says to do. >>>>>>>>>>>>>>>>>>> No need to argue about a fantasy case that doesn't >>>>>>>>>>>>>>>>>>> exist.
*Halting auto problem repair shop analogy* >>>>>>>>>>>>>>>>>> (a) You take your car to the repair shop.
(b) The car is badly in need of a replacement exhaust >>>>>>>>>>>>>>>>>> system.
(c) You ask the head mechanic to inspect your car's >>>>>>>>>>>>>>>>>> exhaust system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the >>>>>>>>>>>>>>>>>> exhaust system.
(f) At the checkout counter you accuse the head >>>>>>>>>>>>>>>>>> mechanic of lying
because your car clearly does not need to have >>>>>>>>>>>>>>>>>> its exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay >>>>>>>>>>>>>>>>>> up or go to jail.
H is asked the question: Does your input need to be >>>>>>>>>>>>>>>>>> aborted to prevent infinite simulation? H correctly >>>>>>>>>>>>>>>>>> answers yes and aborts the simulation.
Nope, H is asked the question, does the machine >>>>>>>>>>>>>>>>> represented by your input finish running in finite time? >>>>>>>>>>>>>>>>>
Does my exhaust system need to be replaced after you >>>>>>>>>>>>>>>> just replaced it?
Why do you say that?
(b) Does the simulation need to be aborted?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final >>>>>>>>>>>>> state when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced? >>>>>>>>>>>> has YES as a correct answer.
We can't say that this answer is wrong on the basis that the >>>>>>>>>>>> answer changes to NO *After the exhaust system has been >>>>>>>>>>>> replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just shows >>>>>>>>>>> you to be a LIAR. NO ONE (except you) is interested in your >>>>>>>>>>> question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem >>>>>>>>>>> of determining, from a description of an arbitrary computer >>>>>>>>>>> program and an input, whether the program will finish
running, or continue to run forever.
We can't say that D(D) halts on the basis that its otherwise >>>>>>>>>> infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you >>>>>>>>> have defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a
specific program. You H DOES abort at a specific point, and
something that does something different is a different program. >>>>>>>>>
Maybe you just don't understand that a program is what it has >>>>>>>>> actually been programmed to be. Maybe you lost your job as a >>>>>>>>> programmer because you don't actually understand what a program >>>>>>>>> is.
This is exactly the same thing as saying that the mechanic >>>>>>>>>> lied about
your car needing a new exhaust system because it doesn't need >>>>>>>>>> one after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes >>>>>>>>> it halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D)
does abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES
abort its simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation
does
D(D) ever terminate normally?
No, but in that Hypothetical case H(D,D) never gives an answer so
fails too.
Do you understand that when D correctly simulated by H has had
its simulation aborted by H that this does not count as normal
termination for D?
Right, but we aren't asked about D simulated by H,
Nope, the question is the question and you don't get to change it.
H getting stuck is its own problem.
On 5/27/2023 1:01 PM, Richard Damon wrote:
On 5/27/23 1:45 PM, olcott wrote:H getting stuck proves that you are out-of-sync with reality by one
On 5/27/2023 12:19 PM, Richard Damon wrote:
On 5/27/23 11:59 AM, olcott wrote:*We must be otherwise H gets stuck in recursive simulation*
On 5/27/2023 7:12 AM, Richard Damon wrote:
On 5/26/23 10:06 PM, olcott wrote:
On 5/26/2023 9:02 PM, Richard Damon wrote:
On 5/26/23 9:58 PM, olcott wrote:
On 5/26/2023 8:53 PM, Richard Damon wrote:
On 5/26/23 9:33 PM, olcott wrote:
On 5/26/2023 8:22 PM, Richard Damon wrote:
On 5/26/23 9:11 PM, olcott wrote:
On 5/26/2023 7:55 PM, Richard Damon wrote:
On 5/26/23 8:41 PM, olcott wrote:
On 5/26/2023 7:10 PM, Richard Damon wrote:
On 5/26/23 7:50 PM, olcott wrote:We cannot say that the YES answer original question: >>>>>>>>>>>>>>> (a) Does the exhaust system need to be replaced? >>>>>>>>>>>>>>> (b) Does the simulation need to be aborted?
On 5/26/2023 6:42 PM, Richard Damon wrote:
On 5/26/23 7:31 PM, olcott wrote:That is asking the question:
On 5/26/2023 11:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/26/23 12:17 PM, olcott wrote:
On 5/26/2023 10:33 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/26/23 11:07 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/26/2023 9:51 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/26/23 1:06 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 11:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:55 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 10:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fritz Feldhase >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <franz.fritschee.ff@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, May 24, 2023 at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:14:36 PM UTC+2, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Following pseudocode for D: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arbitrarily long int D(int start) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arbitrarily long int n
So, which instruction acts differently? >>>>>>>>>>>>>>>>>>>>>>So, you are admitting that H doesn't >>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "terminate normally" and thus fails >>>>>>>>>>>>>>>>>>>>>>>>>>>> to be a decider?= start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while (n is not a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perfect number) { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> n = n + 2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return n >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What would Olcott's "simulating >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider" return (answer) if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with, say, H(D, 1)? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Why would you care? PO's H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns "does not halt" for at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> least some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations (citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so the result >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tells you nothing of interest. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
PO equivocates over whether he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> concerned about just the one case >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> used >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the usual proof's construction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or the general case, but >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> regardless of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what side of that fence he is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently sitting, you can't use >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> his H for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything useful. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> How would it know the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? Will it ever return an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Especially, _if_ there is no >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> odd perfect number?) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On some days he will claim that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he has never said he has a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> general halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, just one that can't be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fooled by the "usual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction". It >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "can't be fooled" because he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply declares that H(H^, H^) == >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer "even though" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^(H^) halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On other days, he throws caution >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the wind and claims the general >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, but again with the set of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting computations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "augmented" by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some unspecified set of halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ones. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, he is also not an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest disputant, because he will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> avoid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving a direct answer to a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple question for years >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (literally years), >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and he will even say >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contradictory things days apart >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (again, citations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> available on request) so it can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> take some time to clear all the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> smoke >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the mirrors. But once he >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has said >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"Yes that is the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer even though P(P) halts." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
in reply to the question "do you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> still assert that H(P,P) == false is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the 'correct' answer even though >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts?" I don't see any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carrying on, or at least I see >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not point in saying anything else. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The one weapon we have against >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cranks is that most can't bear to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any substantive claim. This is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> why they are usually so evasive >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving direct answers -- they >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know they will have to stick with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But once they have made the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake of being clear, we should >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pay them >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the courtesy of quoting them at >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every available opportunity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ben has already agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input according to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sipser approved criteria. (see quote >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below) The Sipser approved >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria is a tautology thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, you MIS-QUOTE him by removing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context, which is just a form of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LYING. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The context does not change the fact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that he agreed that H does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine the halt status >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of D according to the Sisper >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> approved criteria. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because all deciders only compute >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mapping *from their inputs* to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their own accept or reject state >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the only objection to my proof is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it does not get the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> result as a non-input this only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> objection >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is nullified. *My proof is correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by tautology* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>SO, what mapping is this supposed >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to compute, if this is what ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider do, is "Halting" the only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> type of decider? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Remember, Halting is DEFINED as the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE coming to a final state, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and it does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except YOU are one invocation from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the probem. It isn't asking about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulatiion done by H, but by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine that H is TRYING to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate (but can't). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers insist on staying one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation away from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reality. H does correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that D correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because it makes the WRONG decision >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the definition of the problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what does the machine represented >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the input do? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My reviewers only focus on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior after H has already made >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct halt status decision, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly out-of-sync by one >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive invocation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The definition of the problem that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are referring to contradicts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a decider that must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compute the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AN INPUT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to an its own accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You think that H is wrong because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the outer invocation halts only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly aborted. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You know that it is necessarily true >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no invocation would ever halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless the inner invocation was >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted, thus making the termination of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this inner invocation necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I have better words. The termination >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the simulation of D is mandated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the requirements that a halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must always halt, thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proving that this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination is necessarily correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is also mandated to give the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer, which since H(D,D) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, which causes D(D) to Halt, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the only correct answer that H(D,D) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should give is 1, so it is necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
The easily verified fact that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would not terminate unless it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted the simulation of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that H is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report this input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This equally applies to the Peter Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine based halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? H not terminating is its own problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is required to terminate the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> choice to not abort its simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would violate this requirement thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> making this choice necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This also conclusively proves >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its input cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally thus is correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined to be non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So? You still don't get it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
yes, it is required to give an answer in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite time, so it can't just be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programmed to simulate forever. It also is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to return the correct answer, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is true that unless H aborts its >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D that H itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>> never terminates normally that makes it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to do this. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Your software engineering skill must be quite >>>>>>>>>>>>>>>>>>>>>>>>>>> awfully terrible to make a mistake like that. >>>>>>>>>>>>>>>>>>>>>>>>>>
So, does H "Terminate Normally", at which >>>>>>>>>>>>>>>>>>>>>>>>>> point, so does the D, or does H not "Terminate >>>>>>>>>>>>>>>>>>>>>>>>>> Normally" and thus isn't a decider? >>>>>>>>>>>>>>>>>>>>>>>>>>
// The following is written in C >>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
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 D(D);
12 }
*Execution Trace*
main() invokes D(D) at line 11 >>>>>>>>>>>>>>>>>>>>>>>>> executed D(D) invokes H(D,D) that simulates >>>>>>>>>>>>>>>>>>>>>>>>> D(D) at line 03 ...
*keeps repeating*
simulated D(D) invokes simulated H(D,D) that >>>>>>>>>>>>>>>>>>>>>>>>> simulates D(D) at line 03 ... >>>>>>>>>>>>>>>>>>>>>>>>>
The simulated D cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>>>> normally and H will
never return to its caller unless and until H >>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation.
So, why doesn't that happen when main calls H? >>>>>>>>>>>>>>>>>>>>>>>>
H does return to its caller when main calls H. >>>>>>>>>>>>>>>>>>>>>>
H(D,D) always operates the exact same way no matter >>>>>>>>>>>>>>>>>>>>> what calls it.
We have two IDENTICAL initial sequence of >>>>>>>>>>>>>>>>>>>>>> instructions, the entry to H, in one case from >>>>>>>>>>>>>>>>>>>>>> main, and in the other from D, with identical >>>>>>>>>>>>>>>>>>>>>> parameters.
If the results follow different paths, there must >>>>>>>>>>>>>>>>>>>>>> be a first point of departure. What is it. >>>>>>>>>>>>>>>>>>>>>>
D(D) is merely the outer invocation that includes >>>>>>>>>>>>>>>>>>>>> H(D,D) as the inner
invocation. Directly executed H(D,D) always behaves >>>>>>>>>>>>>>>>>>>>> exactly the same
way whenever it is invoked.
So, you admit that D(D) will Halt, so, since H(D,D) >>>>>>>>>>>>>>>>>>>> is asking H to decide if D(D) will Halt, it should >>>>>>>>>>>>>>>>>>>> have answered YES, (1)
Because it is an easily verified fact that neither >>>>>>>>>>>>>>>>>>>>> the directly executed
H(D,D) nor the directly executed D(D) would ever >>>>>>>>>>>>>>>>>>>>> terminate normally
unless H aborts its simulation of D, H is >>>>>>>>>>>>>>>>>>>>> necessarily correct to abort
its simulation of D to meet the requirement that >>>>>>>>>>>>>>>>>>>>> itself must halt.
No it DOES terminate because it DOES abort is >>>>>>>>>>>>>>>>>>>> simulation, since that is what the code says to do. >>>>>>>>>>>>>>>>>>>> No need to argue about a fantasy case that doesn't >>>>>>>>>>>>>>>>>>>> exist.
*Halting auto problem repair shop analogy* >>>>>>>>>>>>>>>>>>> (a) You take your car to the repair shop. >>>>>>>>>>>>>>>>>>> (b) The car is badly in need of a replacement exhaust >>>>>>>>>>>>>>>>>>> system.
(c) You ask the head mechanic to inspect your car's >>>>>>>>>>>>>>>>>>> exhaust system.
(d) The head mechanic tells you it needs to be replaced. >>>>>>>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the >>>>>>>>>>>>>>>>>>> exhaust system.
(f) At the checkout counter you accuse the head >>>>>>>>>>>>>>>>>>> mechanic of lying
because your car clearly does not need to have >>>>>>>>>>>>>>>>>>> its exhaust system
replaced.
(g) You refuse to pay on this basis.
(h) The owner calls the police and they tell you pay >>>>>>>>>>>>>>>>>>> up or go to jail.
H is asked the question: Does your input need to be >>>>>>>>>>>>>>>>>>> aborted to prevent infinite simulation? H correctly >>>>>>>>>>>>>>>>>>> answers yes and aborts the simulation.
Nope, H is asked the question, does the machine >>>>>>>>>>>>>>>>>> represented by your input finish running in finite time? >>>>>>>>>>>>>>>>>>
Does my exhaust system need to be replaced after you >>>>>>>>>>>>>>>>> just replaced it?
Why do you say that?
Except (b) isn't the question of a Halt Decider.
It should be "Does the Machine Described Reach its final >>>>>>>>>>>>>> state when run?"
When your exhaust system needs to be replaced
The question: Does my exhaust system need to be replaced? >>>>>>>>>>>>> has YES as a correct answer.
We can't say that this answer is wrong on the basis that the >>>>>>>>>>>>> answer changes to NO *After the exhaust system has been >>>>>>>>>>>>> replaced*
When we ask Does the input to H terminate normally?
the answer is always NO.
Which ISN'T the question!, and your repeating that just >>>>>>>>>>>> shows you to be a LIAR. NO ONE (except you) is interested in >>>>>>>>>>>> your question.
As you have posted before, from
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem >>>>>>>>>>>> of determining, from a description of an arbitrary computer >>>>>>>>>>>> program and an input, whether the program will finish
running, or continue to run forever.
We can't say that D(D) halts on the basis that its otherwise >>>>>>>>>>> infinite
simulation has already been aborted.
No, we say it halts because when we run it with the H that you >>>>>>>>>> have defined to return 0 when asked H(D,D), it halts.
No one is asking about a simulation.
Your problem is you forget that H has been defined as a
specific program. You H DOES abort at a specific point, and >>>>>>>>>> something that does something different is a different program. >>>>>>>>>>
Maybe you just don't understand that a program is what it has >>>>>>>>>> actually been programmed to be. Maybe you lost your job as a >>>>>>>>>> programmer because you don't actually understand what a
program is.
This is exactly the same thing as saying that the mechanic >>>>>>>>>>> lied about
your car needing a new exhaust system because it doesn't need >>>>>>>>>>> one after
it has been replaced.
Nope, YOU are the one lying.
H DOES abort its simulation and returns 0 to D(D) which makes >>>>>>>>>> it halt.
Do you deny that? That is what you program shows.
So you deny that D(D) would never stop running unless H(D,D) >>>>>>>>> does abort its simulation?
No, D(D) stops running because the H(D,D) that it calls DOES
abort its simmulation and returns the value 0 to it.
In the hypothetical case where H(D,D) never aborts its simulation >>>>>>> does
D(D) ever terminate normally?
No, but in that Hypothetical case H(D,D) never gives an answer so
fails too.
Do you understand that when D correctly simulated by H has had
its simulation aborted by H that this does not count as normal
termination for D?
Right, but we aren't asked about D simulated by H,
Nope, the question is the question and you don't get to change it.
H getting stuck is its own problem.
recursive invocation when you say that D halts.
On 5/27/23 2:19 PM, olcott wrote:
On 5/27/2023 1:16 PM, Richard Damon wrote:
H getting stuck means it failed to answer the question.
*This is a tautology, disagreement is futile*
Not at all. H can correctly see that it would get stuck if it didn't
abort its simulation thus conclusively proving that it is correct to
abort its simulation and report non-halting.
Which is irrelevent. Since H DOES abort and return 0, the actual machine Halts.
On 5/27/2023 1:16 PM, Richard Damon wrote:
H getting stuck means it failed to answer the question.
*This is a tautology, disagreement is futile*
Not at all. H can correctly see that it would get stuck if it didn't
abort its simulation thus conclusively proving that it is correct to
abort its simulation and report non-halting.
On 5/27/2023 2:02 PM, Richard Damon wrote:
On 5/27/23 2:19 PM, olcott wrote:D(D) only stops running after H aborts its simulation of D(D) thus just
On 5/27/2023 1:16 PM, Richard Damon wrote:
H getting stuck means it failed to answer the question.
*This is a tautology, disagreement is futile*
Not at all. H can correctly see that it would get stuck if it didn't
abort its simulation thus conclusively proving that it is correct to
abort its simulation and report non-halting.
Which is irrelevent. Since H DOES abort and return 0, the actual
machine Halts.
like the already replaced exhaust system no longer needs to be replaced
the aborted simulation no longer specifies infinite behavior.
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
On 5/27/23 3:12 PM, olcott wrote:
On 5/27/2023 2:02 PM, Richard Damon wrote:
On 5/27/23 2:19 PM, olcott wrote:D(D) only stops running after H aborts its simulation of D(D) thus just
On 5/27/2023 1:16 PM, Richard Damon wrote:
H getting stuck means it failed to answer the question.
*This is a tautology, disagreement is futile*
Not at all. H can correctly see that it would get stuck if it didn't
abort its simulation thus conclusively proving that it is correct to
abort its simulation and report non-halting.
Which is irrelevent. Since H DOES abort and return 0, the actual
machine Halts.
like the already replaced exhaust system no longer needs to be replaced
the aborted simulation no longer specifies infinite behavior.
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
No, REALITY is the actual machine.
It seems like that to you only because unlike professor Sipser you only
know these things by rote memorization from textbooks and thus have zero ability to generalize from basic principles.
On 5/27/2023 2:17 PM, Richard Damon wrote:
On 5/27/23 3:12 PM, olcott wrote:It seems like that to you only because unlike professor Sipser you only
On 5/27/2023 2:02 PM, Richard Damon wrote:
On 5/27/23 2:19 PM, olcott wrote:D(D) only stops running after H aborts its simulation of D(D) thus just
On 5/27/2023 1:16 PM, Richard Damon wrote:
H getting stuck means it failed to answer the question.
*This is a tautology, disagreement is futile*
Not at all. H can correctly see that it would get stuck if it didn't >>>>> abort its simulation thus conclusively proving that it is correct to >>>>> abort its simulation and report non-halting.
Which is irrelevent. Since H DOES abort and return 0, the actual
machine Halts.
like the already replaced exhaust system no longer needs to be replaced
the aborted simulation no longer specifies infinite behavior.
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
*You insist on staying one recursive invocation away from reality*
No, REALITY is the actual machine.
know these things by rote memorization from textbooks and thus have zero ability to generalize from basic principles.
*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 04.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 124:09:24 |
| Calls: | 6,662 |
| Files: | 12,212 |
| Messages: | 5,334,759 |