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?
(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.
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 ⟨Ĥ⟩.
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? >>>>>>> (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.
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.
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?
(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.
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.
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 would violate this requirement thus making this choice necessarily
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?
(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.
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.
correct. This also conclusively proves that its input cannot possibly terminate normally thus is correctly determined to be non-halting.
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?
(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.
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,
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
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 it >>>>>> aborted the simulation of its input conclusively proves that H is
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?
(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.
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. >>>>>>
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.
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,
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?
Or is H actually two different programs that you claim to be just one?
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 >>> would violate this requirement thus making this choice necessarily
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?
(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.
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.
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.
That you refer to the behavior of executed D after H has already
aborted its simulated of D is one recursive invocation away from
reality.
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
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?
(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.
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.
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,
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.
Or is H actually two different programs that you claim to be just one?
The outer D behaves differently after its own inner D has been aborted
than the inner D that must be aborted behaves.
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:So, you are admitting that H doesn't actually "terminate normally"
On 5/25/23 10:55 PM, olcott wrote: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. >>>
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
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* 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.
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.
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,
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?
Or is H actually two different programs that you claim to be just one?
The outer D behaves differently after its own inner D has been aborted
than the inner D that must be aborted behaves.
Really, at what instruction is there a difference between the ACTUAL EXECUTION of the H(D,D) on the outer level, that called by main, and the H(D,D) call be the D(D) that is called by main?
This has been asked of you, and the answer never provided, because there
is no point this happens.
All you are doing is showinfg that you don't understand what a Turing
Machine actually is and what a correct simulation actually is.
YOU FAIL.
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
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
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* 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.
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.
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,
itself
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.
Or is H actually two different programs that you claim to be just one? >>>>
The outer D behaves differently after its own inner D has been
aborted than the inner D that must be aborted behaves.
Really, at what instruction is there a difference between the ACTUAL
EXECUTION of the H(D,D) on the outer level, that called by main, and
the H(D,D) call be the D(D) that is called by main?
All of the continue to execute
This has been asked of you, and the answer never provided, because
there is no point this happens.
All you are doing is showinfg that you don't understand what a Turing
Machine actually is and what a correct simulation actually is.
YOU FAIL.
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
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
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* 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.
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.
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,
itself
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.
Or is H actually two different programs that you claim to be just one? >>>>
The outer D behaves differently after its own inner D has been
aborted than the inner D that must be aborted behaves.
Really, at what instruction is there a difference between the ACTUAL
EXECUTION of the H(D,D) on the outer level, that called by main, and
the H(D,D) call be the D(D) that is called by main?
All of the continue to execute
This has been asked of you, and the answer never provided, because
there is no point this happens.
All you are doing is showinfg that you don't understand what a Turing
Machine actually is and what a correct simulation actually is.
YOU FAIL.
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
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
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* 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.
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.
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,
itself
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?
What instruction in H acts differently because it was called by D
instead of Main.
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.
What instruction in H acts differently because it was called by D
instead of Main.
Nothing acts differently in H called with (D,D) no matter what calls it.
This simulation invariant is always true:
D correctly simulated by H cannot possibly reach its own line 04
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?
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.
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.
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.
It is also a tautology that when a simulation must be aborted to prevent
the simulator's infinite execution that this simulated input does
specify non-halting behavior to this simulator.
You can call me all kinds of insults and gullible fools will take these insults as rebuttal. The target audience, however, is not gullible
fools.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 103:42:05 |
| Calls: | 6,660 |
| Calls today: | 2 |
| Files: | 12,209 |
| Messages: | 5,335,074 |