On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a non-
pathological way, thus in the same way that ZFC (redefined set theory
and) eliminated Russell's Paradox the previously "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem of defining
a machine that correctly determines from a description of an arbitrary
computer program and an input, whether or not its specified input pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the program
described by the input would halt when given the input that is the rest
of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine cannot
be defined. HH(PP, PP) does correctly determine that its correctly
simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the simulation
that behaves differently than what its corresponding line of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and since you
have been told this in the past, it just shows that you are a LIAR about
this fact.
"Correct Simulation" is defined as a simulation that exactly matches the actual behavior of the machine the input describes.
Thus the only possible correct simulation of the machine PP given input
PP is a simulation that shows it will halt, since that IS the behavior
that will happen when you run PP and give it the input PP, since you
have STIPULATED that HH(PP,PP) will return non-halting (0).
On pages 5 and 6 the correct semantics of the x86 language conclusively
proves that PP correctly simulated by HH cannot possibly reach the final
state of PP and terminate normally.
HH correctly determines that PP never halts
Then why will PP(PP) Halt snce PP(PP) will call HH(PP,PP) which will
return 0 and thus PP will return?
Either HH fails to meet the requirements of being a computation (being a fixed mapping of inputs to outputs) or it gave an incorrect answer.
void PP(ptr x)
{
Â Â int Halt_Status = HH(x, x);
Â Â if (Halt_Status)HERE:
Â Â Â Â goto HERE;
Â Â return;
}
int main()
{
Â Â HH(PP, PP);
}
All of my reviewers that disagreed that the input to HH(PP, PP) was
simulated correctly could not point to a single step of the simulation
of PP by HH where the execution trace of PP was not the exact behavior
that the x86 machine code of PP specified.
These reviewers seemed to believe that the execution trace of PP need
not have the same behavior that its machine code specifies. That is like
saying that 2 + 3 = 17 on the basis of arbitrary whim rather than
correct arithmetic.
No, the execution trace of PP actually DOES need to match the behavior
of the code, and thus the call HH must actually act as if HH was
actually called and the behavior assumed of that call match what
HH(PP,PP) actual does, which is return 0.
You analysis looks at a DIFFERENT HH than actually presented, and thus
your claim that it "Correctly" simulated the input is just a LIE.
HH incorrectly simulates the call to HH as it presumes bhavior different
that what actually happens, because it presume a different HH.
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a non-
pathological way, thus in the same way that ZFC (redefined set theory
and) eliminated Russell's Paradox the previously "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem of defining
a machine that correctly determines from a description of an arbitrary
computer program and an input, whether or not its specified input pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the program
described by the input would halt when given the input that is the
rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine cannot
be defined. HH(PP, PP) does correctly determine that its correctly
simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the simulation
that behaves differently than what its corresponding line of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and since
you have been told this in the past, it just shows that you are a LIAR
about this fact.
"Correct Simulation" is defined as a simulation that exactly matches
the actual behavior of the machine the input describes.
It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the
behavior specified by its machine code.
Thus the only possible correct simulation of the machine PP given
input PP is a simulation that shows it will halt, since that IS the
behavior that will happen when you run PP and give it the input PP,
since you have STIPULATED that HH(PP,PP) will return non-halting (0).
On pages 5 and 6 the correct semantics of the x86 language conclusively
proves that PP correctly simulated by HH cannot possibly reach the final >>> state of PP and terminate normally.
HH correctly determines that PP never halts
Then why will PP(PP) Halt snce PP(PP) will call HH(PP,PP) which will
return 0 and thus PP will return?
Either HH fails to meet the requirements of being a computation (being
a fixed mapping of inputs to outputs) or it gave an incorrect answer.
void PP(ptr x)
{
Â Â int Halt_Status = HH(x, x);
Â Â if (Halt_Status)HERE:
Â Â Â Â goto HERE;
Â Â return;
}
int main()
{
Â Â HH(PP, PP);
}
All of my reviewers that disagreed that the input to HH(PP, PP) was
simulated correctly could not point to a single step of the simulation
of PP by HH where the execution trace of PP was not the exact behavior
that the x86 machine code of PP specified.
These reviewers seemed to believe that the execution trace of PP need
not have the same behavior that its machine code specifies. That is like >>> saying that 2 + 3 = 17 on the basis of arbitrary whim rather than
correct arithmetic.
No, the execution trace of PP actually DOES need to match the behavior
of the code, and thus the call HH must actually act as if HH was
actually called and the behavior assumed of that call match what
HH(PP,PP) actual does, which is return 0.
PP correctly simulated by HH cannot possibly reach the final state of PP whether or not HH ever aborts its correct simulation of PP.
You analysis looks at a DIFFERENT HH than actually presented, and thus
your claim that it "Correctly" simulated the input is just a LIE.
HH incorrectly simulates the call to HH as it presumes bhavior
different that what actually happens, because it presume a different HH.
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an >>>> input, whether the program will finish running, or continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a non-
pathological way, thus in the same way that ZFC (redefined set theory
and) eliminated Russell's Paradox the previously "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem of defining >>>> a machine that correctly determines from a description of an arbitrary >>>> computer program and an input, whether or not its specified input pair >>>> would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the program
described by the input would halt when given the input that is the
rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine cannot >>>> be defined. HH(PP, PP) does correctly determine that its correctly
simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the simulation >>>> that behaves differently than what its corresponding line of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and since
you have been told this in the past, it just shows that you are a
LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly matches
the actual behavior of the machine the input describes.
It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Prove it or you are admitting you are lying.
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an
input, whether the program will finish running, or continue to run >>>>>> forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a non- >>>>>> pathological way, thus in the same way that ZFC (redefined set theory >>>>>> and) eliminated Russell's Paradox the previously "impossible" input >>>>>> ceases to be impossible.
In computability theory, the halting problem is the problem of
defining
a machine that correctly determines from a description of an
arbitrary
computer program and an input, whether or not its specified input
pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the program
described by the input would halt when given the input that is the
rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine
cannot
be defined. HH(PP, PP) does correctly determine that its correctly >>>>>> simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the
simulation
that behaves differently than what its corresponding line of machine- >>>>>> code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and since
you have been told this in the past, it just shows that you are a
LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly
matches the actual behavior of the machine the input describes.
It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will Halt,
the correct simulation of it must match.
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an
input, whether the program will finish running, or continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a non- >>>>> pathological way, thus in the same way that ZFC (redefined set theory >>>>> and) eliminated Russell's Paradox the previously "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem of
defining
a machine that correctly determines from a description of an arbitrary >>>>> computer program and an input, whether or not its specified input pair >>>>> would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the program
described by the input would halt when given the input that is the
rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine
cannot
be defined. HH(PP, PP) does correctly determine that its correctly
simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the
simulation
that behaves differently than what its corresponding line of machine- >>>>> code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and since
you have been told this in the past, it just shows that you are a
LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly matches
the actual behavior of the machine the input describes.
It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.
Prove it or you are admitting you are lying.
It is dead obvious that I am correct. A simulator is only correct when
it simulates exactly what the machine code specifies and incorrect
otherwise.
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program >>>>>>> and an
input, whether the program will finish running, or continue to run >>>>>>> forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a >>>>>>> non-
pathological way, thus in the same way that ZFC (redefined set
theory
and) eliminated Russell's Paradox the previously "impossible" input >>>>>>> ceases to be impossible.
In computability theory, the halting problem is the problem of
defining
a machine that correctly determines from a description of an
arbitrary
computer program and an input, whether or not its specified input >>>>>>> pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the
program described by the input would halt when given the input
that is the rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine >>>>>>> cannot
be defined. HH(PP, PP) does correctly determine that its correctly >>>>>>> simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the
simulation
that behaves differently than what its corresponding line of
machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and
since you have been told this in the past, it just shows that you
are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly
matches the actual behavior of the machine the input describes.
It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the >>>>> behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will Halt,
the correct simulation of it must match.
That is merely a provably false assumption.
Try and provide a 100% specific counter-example where you show a line of machine code such as [mov eax, 1] and the simulator simulates another different line instead such as [push ebx] and the simulator is correct.
If no such counter-example exists then it is proven that the ultimate
measure of correct simulation is that the simulator simulates line-by-
line exactly what the machine code specifies.
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>> determining, from a description of an arbitrary computer program >>>>>>>> and an
input, whether the program will finish running, or continue to run >>>>>>>> forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in a >>>>>>>> non-
pathological way, thus in the same way that ZFC (redefined set >>>>>>>> theory
and) eliminated Russell's Paradox the previously "impossible" input >>>>>>>> ceases to be impossible.
In computability theory, the halting problem is the problem of >>>>>>>> defining
a machine that correctly determines from a description of an
arbitrary
computer program and an input, whether or not its specified
input pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the
program described by the input would halt when given the input
that is the rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a machine >>>>>>>> cannot
be defined. HH(PP, PP) does correctly determine that its correctly >>>>>>>> simulated input cannot possibly reach the final state of PP and >>>>>>>> terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the
simulation
that behaves differently than what its corresponding line of
machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and
since you have been told this in the past, it just shows that you >>>>>>> are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly
matches the actual behavior of the machine the input describes.
It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the >>>>>> behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will
Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), and to
be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the
equivalent to PP, which shows it halts.
Are you admitting you are a liar?
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
Try and provide a 100% specific counter-example where you show a line of
machine code such as [mov eax, 1] and the simulator simulates another
different line instead such as [push ebx] and the simulator is correct.
You simulation of the call HH says it will not return.
The actual execution of the program shows it does.
--
On 1/24/2023 9:40 PM, Richard Damon wrote:
Since the direct eecution of the machine language of PP(PP) will Halt,
the correct simulation of it must match.
That is merely a provably false assumption.
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>>> determining, from a description of an arbitrary computer
program and an
input, whether the program will finish running, or continue to run >>>>>>>>> forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in >>>>>>>>> a non-
pathological way, thus in the same way that ZFC (redefined set >>>>>>>>> theory
and) eliminated Russell's Paradox the previously "impossible" >>>>>>>>> input
ceases to be impossible.
In computability theory, the halting problem is the problem of >>>>>>>>> defining
a machine that correctly determines from a description of an >>>>>>>>> arbitrary
computer program and an input, whether or not its specified
input pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the
program described by the input would halt when given the input >>>>>>>> that is the rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a
machine cannot
be defined. HH(PP, PP) does correctly determine that its correctly >>>>>>>>> simulated input cannot possibly reach the final state of PP and >>>>>>>>> terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the >>>>>>>>> simulation
that behaves differently than what its corresponding line of >>>>>>>>> machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and
since you have been told this in the past, it just shows that
you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly
matches the actual behavior of the machine the input describes. >>>>>>>>
It turns out that is incorrect. The ultimate measure of a correct >>>>>>> simulation is whether or not the simulated input exactly matches the >>>>>>> behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will
Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), and to
be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the
equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
Are you admitting you are a liar?
You should be smart enough to determine that I am not a Liar.
A mere Liar could not stay motivated for this long.
A mere liar would not have created an operating system.
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
Try and provide a 100% specific counter-example where you show a line of >>> machine code such as [mov eax, 1] and the simulator simulates another
different line instead such as [push ebx] and the simulator is correct.
You simulation of the call HH says it will not return.
The actual execution of the program shows it does.
--
hits a target no one else can see." Arthur Schopenhauer
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
Since the direct eecution of the machine language of PP(PP) will
Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Simple question for a counter.
You seem to be saying that when PP calls HH(PP,PP) then HH will not
return, but when main call HH(PP,PP) it will
Please show the first assembly instruction of these two exectution paths
that differ in operation.
On 1/25/23 12:13 AM, olcott wrote:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>>>> determining, from a description of an arbitrary computer
program and an
input, whether the program will finish running, or continue to >>>>>>>>>> run
forever.Â https://en.wikipedia.org/wiki/Halting_problem
This definition of the halting problem measures correctness in >>>>>>>>>> a non-
pathological way, thus in the same way that ZFC (redefined set >>>>>>>>>> theory
and) eliminated Russell's Paradox the previously "impossible" >>>>>>>>>> input
ceases to be impossible.
In computability theory, the halting problem is the problem of >>>>>>>>>> defining
a machine that correctly determines from a description of an >>>>>>>>>> arbitrary
computer program and an input, whether or not its specified >>>>>>>>>> input pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the
program described by the input would halt when given the input >>>>>>>>> that is the rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a
machine cannot
be defined. HH(PP, PP) does correctly determine that its
correctly
simulated input cannot possibly reach the final state of PP and >>>>>>>>>> terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the >>>>>>>>>> simulation
that behaves differently than what its corresponding line of >>>>>>>>>> machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and >>>>>>>>> since you have been told this in the past, it just shows that >>>>>>>>> you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly >>>>>>>>> matches the actual behavior of the machine the input describes. >>>>>>>>>
It turns out that is incorrect. The ultimate measure of a correct >>>>>>>> simulation is whether or not the simulated input exactly matches >>>>>>>> the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will
Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), and
to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the
equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's
paradox has no answer.
On 1/25/23 11:51 AM, olcott wrote:
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>>>>>> determining, from a description of an arbitrary computer >>>>>>>>>>>> program and anRight, the Decider must decide if the actual running of the >>>>>>>>>>> program described by the input would halt when given the >>>>>>>>>>> input that is the rest of that input.
input, whether the program will finish running, or continue >>>>>>>>>>>> to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>>
This definition of the halting problem measures correctness >>>>>>>>>>>> in a non-
pathological way, thus in the same way that ZFC (redefined >>>>>>>>>>>> set theory
and) eliminated Russell's Paradox the previously
"impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem >>>>>>>>>>>> of defining
a machine that correctly determines from a description of an >>>>>>>>>>>> arbitrary
computer program and an input, whether or not its specified >>>>>>>>>>>> input pair
would terminate normally by reaching it own final state. >>>>>>>>>>>
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of PP and >>>>>>>>>>>> terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the >>>>>>>>>>>> simulation
that behaves differently than what its corresponding line of >>>>>>>>>>>> machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and >>>>>>>>>>> since you have been told this in the past, it just shows that >>>>>>>>>>> you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly >>>>>>>>>>> matches the actual behavior of the machine the input describes. >>>>>>>>>>>
It turns out that is incorrect. The ultimate measure of a correct >>>>>>>>>> simulation is whether or not the simulated input exactly
matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not >>>>>>>> simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will >>>>>>> Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), and
to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the
equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's
paradox has no answer.
No, your RESTATEMENT is ill-defined. The behavior of P is well defined
given a proper definition of H
H(P,P) can do one of 4 things, and can't do anything else.
1) H(P,P) can return 0, in which case P(P) will halt, and H is shown to
be wrong. This is what you claim your H does when directly called.
2) H(P,P) can retrun 1, in which case, P(P) will go into an infinite
loop, and H is shown to be wrong.
3) H(P,P) can just dies and halt and not return an answer, in which case
H fails to be the needed halt decider, and P(P) will be halting.
4) H(P,P) can get stuck in an infinte loop, and never return an answer,
in which case H fails to be the needed halt decider, and P(P) will be non-halting. This is what you seem to claim is what H does when
simulated inside P.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, *and a unique solution can be shown to
exist*
Right, and given an actual definition of the complete algorithm of H
(and 'Get the right answer' is NOT an complete algorithm) there is a
precise correct answer to the problem.
Unfortunately of H, H can never give that answer.
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>>>>> determining, from a description of an arbitrary computer >>>>>>>>>>> program and an
input, whether the program will finish running, or continue >>>>>>>>>>> to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>
This definition of the halting problem measures correctness >>>>>>>>>>> in a non-
pathological way, thus in the same way that ZFC (redefined >>>>>>>>>>> set theory
and) eliminated Russell's Paradox the previously "impossible" >>>>>>>>>>> input
ceases to be impossible.
In computability theory, the halting problem is the problem >>>>>>>>>>> of defining
a machine that correctly determines from a description of an >>>>>>>>>>> arbitrary
computer program and an input, whether or not its specified >>>>>>>>>>> input pair
would terminate normally by reaching it own final state.
Right, the Decider must decide if the actual running of the >>>>>>>>>> program described by the input would halt when given the input >>>>>>>>>> that is the rest of that input.
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of PP and >>>>>>>>>>> terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of the >>>>>>>>>>> simulation
that behaves differently than what its corresponding line of >>>>>>>>>>> machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", and >>>>>>>>>> since you have been told this in the past, it just shows that >>>>>>>>>> you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly >>>>>>>>>> matches the actual behavior of the machine the input describes. >>>>>>>>>>
It turns out that is incorrect. The ultimate measure of a correct >>>>>>>>> simulation is whether or not the simulated input exactly
matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not >>>>>>> simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will
Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), and
to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the
equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's
paradox has no answer.
In the study of problem solving, any problem in which the initial state
or starting position, the allowable operations, and the goal state are clearly specified, *and a unique solution can be shown to exist*
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
Now finally Oxford agrees with me on this 8 years later:
Feb 20, 2015, 11:38:48 AMÂ sci.lang
The logical law of polar questions
When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.
All polar questions (including incorrect polar questions)
have exactly one answer from the following:
1) No
2) Yes
3) Neither // Only applies to incorrect polar questions
Copyright Olcott 2015 https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
In the same way that ZFC eliminated Russell's Paradox by redefining set theory to eliminate a key element of Russell's Paradox a set as a member
of itself, the Halting Problem is redefined eliminating its pathology.
The halting problem is the problem of defining a machine that correctly determines from a description of an arbitrary computer program and an
input, whether or not its specified input pair would terminate normally
by reaching it own final state on the basis of its correct simulation of
this input pair.
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not reviewed or agreed to anything else):
Â If simulating halt decider H correctly simulates its input D until
Â H correctly determines that its simulated D would never stop running
Â unless aborted then H can abort its simulation of D and correctly
Â report that D specifies a non-halting sequence of configurations.
On 1/25/2023 5:15 PM, Richard Damon wrote:
On 1/25/23 11:51 AM, olcott wrote:
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>>>>>>> determining, from a description of an arbitrary computer >>>>>>>>>>>>> program and anRight, the Decider must decide if the actual running of the >>>>>>>>>>>> program described by the input would halt when given the >>>>>>>>>>>> input that is the rest of that input.
input, whether the program will finish running, or continue >>>>>>>>>>>>> to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>>>
This definition of the halting problem measures correctness >>>>>>>>>>>>> in a non-
pathological way, thus in the same way that ZFC (redefined >>>>>>>>>>>>> set theory
and) eliminated Russell's Paradox the previously
"impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem >>>>>>>>>>>>> of defining
a machine that correctly determines from a description of >>>>>>>>>>>>> an arbitrary
computer program and an input, whether or not its specified >>>>>>>>>>>>> input pair
would terminate normally by reaching it own final state. >>>>>>>>>>>>
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of PP >>>>>>>>>>>>> and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of >>>>>>>>>>>>> the simulation
that behaves differently than what its corresponding line >>>>>>>>>>>>> of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", >>>>>>>>>>>> and since you have been told this in the past, it just shows >>>>>>>>>>>> that you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly >>>>>>>>>>>> matches the actual behavior of the machine the input describes. >>>>>>>>>>>>
It turns out that is incorrect. The ultimate measure of a >>>>>>>>>>> correct
simulation is whether or not the simulated input exactly >>>>>>>>>>> matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does >>>>>>>>> not simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will >>>>>>>> Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP),
and to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the >>>>>> equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's
paradox has no answer.
No, your RESTATEMENT is ill-defined. The behavior of P is well defined
given a proper definition of H
H(P,P) can do one of 4 things, and can't do anything else.
1) H(P,P) can return 0, in which case P(P) will halt, and H is shown
to be wrong. This is what you claim your H does when directly called.
2) H(P,P) can retrun 1, in which case, P(P) will go into an infinite
loop, and H is shown to be wrong.
3) H(P,P) can just dies and halt and not return an answer, in which
case H fails to be the needed halt decider, and P(P) will be halting.
4) H(P,P) can get stuck in an infinte loop, and never return an
answer, in which case H fails to be the needed halt decider, and P(P)
will be non-halting. This is what you seem to claim is what H does
when simulated inside P.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, *and a unique solution can be shown to
exist*
Right, and given an actual definition of the complete algorithm of H
(and 'Get the right answer' is NOT an complete algorithm) there is a
precise correct answer to the problem.
Unfortunately of H, H can never give that answer.
Thus making the halting problem ill-defined.
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
On 1/25/2023 5:15 PM, Richard Damon wrote:
On 1/25/23 11:51 AM, olcott wrote:
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the problem of >>>>>>>>>>>>> determining, from a description of an arbitrary computer >>>>>>>>>>>>> program and anRight, the Decider must decide if the actual running of the >>>>>>>>>>>> program described by the input would halt when given the >>>>>>>>>>>> input that is the rest of that input.
input, whether the program will finish running, or continue >>>>>>>>>>>>> to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>>>
This definition of the halting problem measures correctness >>>>>>>>>>>>> in a non-
pathological way, thus in the same way that ZFC (redefined >>>>>>>>>>>>> set theory
and) eliminated Russell's Paradox the previously
"impossible" input
ceases to be impossible.
In computability theory, the halting problem is the problem >>>>>>>>>>>>> of defining
a machine that correctly determines from a description of >>>>>>>>>>>>> an arbitrary
computer program and an input, whether or not its specified >>>>>>>>>>>>> input pair
would terminate normally by reaching it own final state. >>>>>>>>>>>>
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of PP >>>>>>>>>>>>> and
terminate normally. (See pages 5-6 of this paper)
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of >>>>>>>>>>>>> the simulation
that behaves differently than what its corresponding line >>>>>>>>>>>>> of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", >>>>>>>>>>>> and since you have been told this in the past, it just shows >>>>>>>>>>>> that you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that exactly >>>>>>>>>>>> matches the actual behavior of the machine the input describes. >>>>>>>>>>>>
It turns out that is incorrect. The ultimate measure of a >>>>>>>>>>> correct
simulation is whether or not the simulated input exactly >>>>>>>>>>> matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does >>>>>>>>> not simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) will >>>>>>>> Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP),
and to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of the >>>>>> equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's
paradox has no answer.
No, your RESTATEMENT is ill-defined. The behavior of P is well defined
given a proper definition of H
H(P,P) can do one of 4 things, and can't do anything else.
1) H(P,P) can return 0, in which case P(P) will halt, and H is shown
to be wrong. This is what you claim your H does when directly called.
2) H(P,P) can retrun 1, in which case, P(P) will go into an infinite
loop, and H is shown to be wrong.
3) H(P,P) can just dies and halt and not return an answer, in which
case H fails to be the needed halt decider, and P(P) will be halting.
4) H(P,P) can get stuck in an infinte loop, and never return an
answer, in which case H fails to be the needed halt decider, and P(P)
will be non-halting. This is what you seem to claim is what H does
when simulated inside P.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, *and a unique solution can be shown to
exist*
Right, and given an actual definition of the complete algorithm of H
(and 'Get the right answer' is NOT an complete algorithm) there is a
precise correct answer to the problem.
Unfortunately of H, H can never give that answer.
Thus making the halting problem ill-defined.
On 1/25/23 6:51 PM, olcott wrote:
On 1/25/2023 5:29 PM, olcott wrote:
On 1/25/2023 5:15 PM, Richard Damon wrote:
On 1/25/23 11:51 AM, olcott wrote:
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the >>>>>>>>>>>>>>> problem ofRight, the Decider must decide if the actual running of >>>>>>>>>>>>>> the program described by the input would halt when given >>>>>>>>>>>>>> the input that is the rest of that input.
determining, from a description of an arbitrary computer >>>>>>>>>>>>>>> program and an
input, whether the program will finish running, or >>>>>>>>>>>>>>> continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>>>>>
This definition of the halting problem measures
correctness in a non-
pathological way, thus in the same way that ZFC
(redefined set theory
and) eliminated Russell's Paradox the previously >>>>>>>>>>>>>>> "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the >>>>>>>>>>>>>>> problem of defining
a machine that correctly determines from a description of >>>>>>>>>>>>>>> an arbitrary
computer program and an input, whether or not its >>>>>>>>>>>>>>> specified input pair
would terminate normally by reaching it own final state. >>>>>>>>>>>>>>
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of >>>>>>>>>>>>>>> PP and
terminate normally. (See pages 5-6 of this paper) >>>>>>>>>>>>>>>
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of >>>>>>>>>>>>>>> the simulation
that behaves differently than what its corresponding line >>>>>>>>>>>>>>> of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", >>>>>>>>>>>>>> and since you have been told this in the past, it just >>>>>>>>>>>>>> shows that you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that >>>>>>>>>>>>>> exactly matches the actual behavior of the machine the >>>>>>>>>>>>>> input describes.
It turns out that is incorrect. The ultimate measure of a >>>>>>>>>>>>> correct
simulation is whether or not the simulated input exactly >>>>>>>>>>>>> matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does >>>>>>>>>>> not simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) >>>>>>>>>> will Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), >>>>>>>> and to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of >>>>>>>> the equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot >>>>>>> possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's >>>>>> paradox has no answer.
No, your RESTATEMENT is ill-defined. The behavior of P is well
defined given a proper definition of H
H(P,P) can do one of 4 things, and can't do anything else.
1) H(P,P) can return 0, in which case P(P) will halt, and H is shown
to be wrong. This is what you claim your H does when directly called.
2) H(P,P) can retrun 1, in which case, P(P) will go into an infinite
loop, and H is shown to be wrong.
3) H(P,P) can just dies and halt and not return an answer, in which
case H fails to be the needed halt decider, and P(P) will be halting.
4) H(P,P) can get stuck in an infinte loop, and never return an
answer, in which case H fails to be the needed halt decider, and
P(P) will be non-halting. This is what you seem to claim is what H
does when simulated inside P.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, *and a unique solution can be shown to
exist*
Right, and given an actual definition of the complete algorithm of H
(and 'Get the right answer' is NOT an complete algorithm) there is a
precise correct answer to the problem.
Unfortunately of H, H can never give that answer.
Thus making the halting problem ill-defined.
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not in the same way and for the
same reason that there is no barber that shaves all and only those that
do not shave themselves. ZFC eliminated this problem by declaring it is
erroneous.
Right, which shows that the Haltng Theorm is CORRECT, that that the
Halting Function is not computable.
So, you agree with the Theorem that you have been arguing against for 2 decades?
Every decision problem where
*a unique solution CANNOT be shown to exist*
is erroneous.
Nope, just shows that the problem is not computable.
If you think uncompuatable problems are erroneous, then you can't handle
all of mathematics.
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
All these years pretending you have written one... You should feel
sad, right? You shouldn't, at end you've admitted the obvious
truth.
Note that a function that is an halt decider is perfectly well
defined. So no, the "problem" is NOT ill-defined (whatever that
means).
On 1/25/23 6:51 PM, olcott wrote:
On 1/25/2023 5:29 PM, olcott wrote:
On 1/25/2023 5:15 PM, Richard Damon wrote:
On 1/25/23 11:51 AM, olcott wrote:
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the >>>>>>>>>>>>>>> problem ofRight, the Decider must decide if the actual running of >>>>>>>>>>>>>> the program described by the input would halt when given >>>>>>>>>>>>>> the input that is the rest of that input.
determining, from a description of an arbitrary computer >>>>>>>>>>>>>>> program and an
input, whether the program will finish running, or >>>>>>>>>>>>>>> continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>>>>>
This definition of the halting problem measures
correctness in a non-
pathological way, thus in the same way that ZFC
(redefined set theory
and) eliminated Russell's Paradox the previously >>>>>>>>>>>>>>> "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the >>>>>>>>>>>>>>> problem of defining
a machine that correctly determines from a description of >>>>>>>>>>>>>>> an arbitrary
computer program and an input, whether or not its >>>>>>>>>>>>>>> specified input pair
would terminate normally by reaching it own final state. >>>>>>>>>>>>>>
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of >>>>>>>>>>>>>>> PP and
terminate normally. (See pages 5-6 of this paper) >>>>>>>>>>>>>>>
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of >>>>>>>>>>>>>>> the simulation
that behaves differently than what its corresponding line >>>>>>>>>>>>>>> of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", >>>>>>>>>>>>>> and since you have been told this in the past, it just >>>>>>>>>>>>>> shows that you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that >>>>>>>>>>>>>> exactly matches the actual behavior of the machine the >>>>>>>>>>>>>> input describes.
It turns out that is incorrect. The ultimate measure of a >>>>>>>>>>>>> correct
simulation is whether or not the simulated input exactly >>>>>>>>>>>>> matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does >>>>>>>>>>> not simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) >>>>>>>>>> will Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), >>>>>>>> and to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of >>>>>>>> the equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH cannot >>>>>>> possibly reach it own final state.
But that isn't the questipon, since that question, like the Liar's >>>>>> paradox has no answer.
No, your RESTATEMENT is ill-defined. The behavior of P is well
defined given a proper definition of H
H(P,P) can do one of 4 things, and can't do anything else.
1) H(P,P) can return 0, in which case P(P) will halt, and H is shown
to be wrong. This is what you claim your H does when directly called.
2) H(P,P) can retrun 1, in which case, P(P) will go into an infinite
loop, and H is shown to be wrong.
3) H(P,P) can just dies and halt and not return an answer, in which
case H fails to be the needed halt decider, and P(P) will be halting.
4) H(P,P) can get stuck in an infinte loop, and never return an
answer, in which case H fails to be the needed halt decider, and
P(P) will be non-halting. This is what you seem to claim is what H
does when simulated inside P.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, *and a unique solution can be shown to
exist*
Right, and given an actual definition of the complete algorithm of H
(and 'Get the right answer' is NOT an complete algorithm) there is a
precise correct answer to the problem.
Unfortunately of H, H can never give that answer.
Thus making the halting problem ill-defined.
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not in the same way and for the
same reason that there is no barber that shaves all and only those that
do not shave themselves. ZFC eliminated this problem by declaring it is
erroneous.
Right, which shows that the Haltng Theorm is CORRECT, that that the
Halting Function is not computable.
So, you agree with the Theorem that you have been arguing against for 2 decades?
Every decision problem where
*a unique solution CANNOT be shown to exist*
is erroneous.
Nope, just shows that the problem is not computable.
On 1/25/23 7:23 PM, Richard Damon wrote:
On 1/25/23 6:51 PM, olcott wrote:
On 1/25/2023 5:29 PM, olcott wrote:
On 1/25/2023 5:15 PM, Richard Damon wrote:
On 1/25/23 11:51 AM, olcott wrote:
On 1/25/2023 5:46 AM, Richard Damon wrote:
On 1/25/23 12:13 AM, olcott wrote:That makes the Halting Problem ill-defined:
On 1/24/2023 10:09 PM, Richard Damon wrote:
On 1/24/23 10:51 PM, olcott wrote:
On 1/24/2023 9:40 PM, Richard Damon wrote:
On 1/24/23 10:10 PM, olcott wrote:
On 1/24/2023 8:03 PM, Richard Damon wrote:
On 1/24/23 7:26 PM, olcott wrote:
On 1/24/2023 5:41 PM, Richard Damon wrote:
On 1/24/23 10:41 AM, olcott wrote:
In computability theory, the halting problem is the >>>>>>>>>>>>>>>> problem ofRight, the Decider must decide if the actual running of >>>>>>>>>>>>>>> the program described by the input would halt when given >>>>>>>>>>>>>>> the input that is the rest of that input.
determining, from a description of an arbitrary computer >>>>>>>>>>>>>>>> program and an
input, whether the program will finish running, or >>>>>>>>>>>>>>>> continue to run
forever.Â https://en.wikipedia.org/wiki/Halting_problem >>>>>>>>>>>>>>>>
This definition of the halting problem measures >>>>>>>>>>>>>>>> correctness in a non-
pathological way, thus in the same way that ZFC >>>>>>>>>>>>>>>> (redefined set theory
and) eliminated Russell's Paradox the previously >>>>>>>>>>>>>>>> "impossible" input
ceases to be impossible.
In computability theory, the halting problem is the >>>>>>>>>>>>>>>> problem of defining
a machine that correctly determines from a description >>>>>>>>>>>>>>>> of an arbitrary
computer program and an input, whether or not its >>>>>>>>>>>>>>>> specified input pair
would terminate normally by reaching it own final state. >>>>>>>>>>>>>>>
It is NOT asking if the
The conventional proofs do not actually show that such a >>>>>>>>>>>>>>>> machine cannot
be defined. HH(PP, PP) does correctly determine that its >>>>>>>>>>>>>>>> correctly
simulated input cannot possibly reach the final state of >>>>>>>>>>>>>>>> PP and
terminate normally. (See pages 5-6 of this paper) >>>>>>>>>>>>>>>>
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
If the simulation is incorrect then there must a line of >>>>>>>>>>>>>>>> the simulation
that behaves differently than what its corresponding >>>>>>>>>>>>>>>> line of machine-
code specifies.
No, it is incorrect because it is incomplete.
You are just usong the INCORRECT definition of "Correct", >>>>>>>>>>>>>>> and since you have been told this in the past, it just >>>>>>>>>>>>>>> shows that you are a LIAR about this fact.
"Correct Simulation" is defined as a simulation that >>>>>>>>>>>>>>> exactly matches the actual behavior of the machine the >>>>>>>>>>>>>>> input describes.
It turns out that is incorrect. The ultimate measure of a >>>>>>>>>>>>>> correct
simulation is whether or not the simulated input exactly >>>>>>>>>>>>>> matches the
behavior specified by its machine code.
Nope, Sourcd for that claim.
Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does >>>>>>>>>>>> not simulate what the machine language specifies.
This is the counter example.
Since the direct eecution of the machine language of PP(PP) >>>>>>>>>>> will Halt, the correct simulation of it must match.
That is merely a provably false assumption.
Then do so.
Remember, your HH has been admitted to return 0 from HH(PP,PP), >>>>>>>>> and to be a computation, it must do the same to EVERY call.
YOU have posted the execution trace of the direct execution of >>>>>>>>> the equivalent to PP, which shows it halts.
You can see on pages 5-6 that PP correctly simulated by HH
cannot possibly reach it own final state.
But that isn't the questipon, since that question, like the
Liar's paradox has no answer.
No, your RESTATEMENT is ill-defined. The behavior of P is well
defined given a proper definition of H
H(P,P) can do one of 4 things, and can't do anything else.
1) H(P,P) can return 0, in which case P(P) will halt, and H is
shown to be wrong. This is what you claim your H does when directly
called.
2) H(P,P) can retrun 1, in which case, P(P) will go into an
infinite loop, and H is shown to be wrong.
3) H(P,P) can just dies and halt and not return an answer, in which
case H fails to be the needed halt decider, and P(P) will be halting. >>>>>
4) H(P,P) can get stuck in an infinte loop, and never return an
answer, in which case H fails to be the needed halt decider, and
P(P) will be non-halting. This is what you seem to claim is what H
does when simulated inside P.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal >>>>>> state are clearly specified, *and a unique solution can be shown
to exist*
Right, and given an actual definition of the complete algorithm of
H (and 'Get the right answer' is NOT an complete algorithm) there
is a precise correct answer to the problem.
Unfortunately of H, H can never give that answer.
Thus making the halting problem ill-defined.
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not in the same way and for the >>> same reason that there is no barber that shaves all and only those that
do not shave themselves. ZFC eliminated this problem by declaring it is
erroneous.
Right, which shows that the Haltng Theorm is CORRECT, that that the
Halting Function is not computable.
So, you agree with the Theorem that you have been arguing against for
2 decades?
Every decision problem where
*a unique solution CANNOT be shown to exist*
is erroneous.
Nope, just shows that the problem is not computable.
If you think uncompuatable problems are erroneous, then you can't
handle all of mathematics.
One simple comment that comes to mind that points out the error in your thinking:
The number of possible computing machines is a countable infinite,
because we can express every such machine as a finite string of a finite symbol set.
The number of possible deciders that can be defined is an UNCOUNTABLE infinite.
Thus, there are deciders that can not be computed, in fact, MOST
deciders can't be computed. (Admittedly a randomly chosen decider likely isn't useful).
I suspect you aren't going to understand this, as you can't seem to
handle the actual concept of infinity.
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that* There is a program H that can divide all of its
inputs into halting and non-halting on the basis of the behavior of this input D correctly simulated by H.
Â Â In the study of problem solving, any problem in which the
Â Â initial state or starting position, the allowable operations,
Â Â and the goal state are clearly specified, and a unique
Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
When a simulating halt decider H is only required to report on the the behavior of D correctly simulated by H, then the problem has a solution.
All these years pretending you have written one... You should feel
sad, right? You shouldn't, at end you've admitted the obvious
truth.
Note that a function that is an halt decider is perfectly well
defined. So no, the "problem" is NOT ill-defined (whatever that
means).
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input >>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Â Â In the study of problem solving, any problem in which the
Â Â initial state or starting position, the allowable operations,
Â Â and the goal state are clearly specified, and a unique
Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
*This corrects the error with the definition of the halting problem*
When a simulating halt decider H is only required to report on the
behavior of D correctly simulated by H, then this problem has a
solution.
*ZFC eliminated Russell's Paradox by redefining the problem*
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input >>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Â Â In the study of problem solving, any problem in which the
Â Â initial state or starting position, the allowable operations,
Â Â and the goal state are clearly specified, and a unique
Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is ill-defined
Le 26/01/2023 Ã 02:06, Ben Bacarisse a Ã©critÂ :
Python <python@invalid.org> writes:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
Not so fast!Â Remember that PO is often fractally wrong.Â Not only is he >> usually wrong about the big picture he's usually wrong about all the
details too.Â In this case, he's having trouble expressing what he
means.Â This is actually just another iteration of his "it's an invalid
question" stance, badly phrased.
So he is right, for once, by what he actually wrote expressed
badly a faulty claim. As far as know him, he's definitely able to to
that. Quite a paradox in a way, of his kind... :-)
Taken word for word the sentence of him I quoted is actually quite
right and expressed the actual opposite of all he claimed for years.
On 1/25/2023 7:16 PM, Python wrote:
Le 26/01/2023 Ã 02:06, Ben Bacarisse a Ã©critÂ :
Python <python@invalid.org> writes:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input >>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
Not so fast!Â Remember that PO is often fractally wrong.Â Not only is he >>> usually wrong about the big picture he's usually wrong about all the
details too.Â In this case, he's having trouble expressing what he
means.Â This is actually just another iteration of his "it's an invalid >>> question" stance, badly phrased.
So he is right, for once, by what he actually wrote expressed
badly a faulty claim. As far as know him, he's definitely able to to
that. Quite a paradox in a way, of his kind... :-)
Taken word for word the sentence of him I quoted is actually quite
right and expressed the actual opposite of all he claimed for years.
Â Â In the study of problem solving, any problem in which the initial
Â Â state or starting position, the allowable operations, and the goal
Â Â state are clearly specified, and a unique solution can be shown to
Â Â exist.
*a unique solution can be shown to exist* or the problem itself is ill-defined
Le 26/01/2023 Ã 01:54, olcott a Ã©critÂ :
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>> strings into those that represent machines would halt on their input >>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
Either a program stops or not. This is not ill-defined at all.
Le 26/01/2023 Ã 01:54, olcott a Ã©critÂ :
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>> strings into those that represent machines would halt on their input >>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
Either a program stops or not. This is not ill-defined at all.
And you are right : no program can decide on that from its input.
You should be happy to have been right ONCE in your entire life.
On 1/25/2023 7:18 PM, Python wrote:
Le 26/01/2023 Ã 01:54, olcott a Ã©critÂ :
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>>> strings into those that represent machines would halt on their input >>>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions! >>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
Either a program stops or not. This is not ill-defined at all.
The problem of defining a machine that correctly determines whether or
not any arbitrary pair of finite strings represents a halting
computation or not can be solved by a simulating halt decider.
The problem of passing the correct answer through a liar that reverses
this answer cannot be solved.
On 1/25/2023 7:18 PM, Python wrote:
Le 26/01/2023 Ã 01:54, olcott a Ã©critÂ :
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>>> strings into those that represent machines would halt on their input >>>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions! >>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
Either a program stops or not. This is not ill-defined at all.
The problem of defining a machine that correctly determines whether or
not any arbitrary pair of finite strings represents a halting
computation or not can be solved by a simulating halt decider.
The problem of passing the correct answer through a liar that reverses
this answer cannot be solved.
On 1/25/23 8:23 PM, olcott wrote:
On 1/25/2023 7:06 PM, Ben Bacarisse wrote:
Python <python@invalid.org> writes:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input >>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
Not so fast!Â Remember that PO is often fractally wrong.Â Not only is he >>> usually wrong about the big picture he's usually wrong about all the
details too.Â In this case, he's having trouble expressing what he
means.Â This is actually just another iteration of his "it's an invalid >>> question" stance, badly phrased.
*This time www.oxfordreference.com agrees*
Â Â Â In the study of problem solving, any problem in which the initial
Â Â Â state or starting position, the allowable operations, and the goal
Â Â Â state are clearly specified, and a unique solution can be shown to
Â Â Â exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
But using the definitions of a DIFFERENT Field.
On 1/25/23 7:54 PM, olcott wrote:
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>> strings into those that represent machines would halt on their input >>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Not by the definition of Conputation theory
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
Which is from a different field with different definition.
They are talking about PUZZLES as "Problems".
You are just showing your ignorance of the topic, an ignorance you
imposed on yourself by refusing to actually trying to learn any of the
topic (or being unable due to mental definciencies)
On 1/25/23 8:32 PM, olcott wrote:
On 1/25/2023 7:18 PM, Python wrote:
Le 26/01/2023 Ã 01:54, olcott a Ã©critÂ :
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>>>> strings into those that represent machines would halt on their >>>>>>>> input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions! >>>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement. >>>>>
*This makes the current definition of the halting problem ill-defined* >>>> Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
Either a program stops or not. This is not ill-defined at all.
The problem of defining a machine that correctly determines whether or
not any arbitrary pair of finite strings represents a halting
computation or not can be solved by a simulating halt decider.
But it isn't a problem of the type described.
The Halting Problem does NOT start for a specified initial state, and
end in another specified final state, and there is not a specifically
listed set of operations allowed (just that it must use a computation).
On 1/25/2023 7:09 PM, Richard Damon wrote:
On 1/25/23 7:54 PM, olcott wrote:
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>>> strings into those that represent machines would halt on their input >>>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions! >>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement.
*This makes the current definition of the halting problem ill-defined*
Not by the definition of Conputation theory
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
Which is from a different field with different definition.
They are talking about PUZZLES as "Problems".
You are just showing your ignorance of the topic, an ignorance you
imposed on yourself by refusing to actually trying to learn any of the
topic (or being unable due to mental definciencies)
They are merely saying what I have been saying all along yet applying it simultaneously to all fields.
I have been saying the every undecidable decision problem is necessarily erroneous, thus not any sort of legitimate problem at all.
My first key breakthrough on this was my
*logical law of polar questions*
When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.
All polar questions (including incorrect polar questions)
have exactly one answer from the following:
1) No
2) Yes
3) Neither // Only applies to incorrect polar questions
Copyright 2015 PL Olcott https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
On 1/25/2023 7:32 PM, Richard Damon wrote:
On 1/25/23 8:23 PM, olcott wrote:
On 1/25/2023 7:06 PM, Ben Bacarisse wrote:
Python <python@invalid.org> writes:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>> strings into those that represent machines would halt on their input >>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!
Not so fast!Â Remember that PO is often fractally wrong.Â Not only
is he
usually wrong about the big picture he's usually wrong about all the
details too.Â In this case, he's having trouble expressing what he
means.Â This is actually just another iteration of his "it's an invalid >>>> question" stance, badly phrased.
*This time www.oxfordreference.com agrees*
Â Â Â In the study of problem solving, any problem in which the initial >>> Â Â Â state or starting position, the allowable operations, and the goal >>> Â Â Â state are clearly specified, and a unique solution can be shown to >>> Â Â Â exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
But using the definitions of a DIFFERENT Field.
Their statement universally applies to all problems including decision problems. I have known this all along, finally the rest of the world is beginning to catch up.
On 1/25/2023 7:40 PM, Richard Damon wrote:
On 1/25/23 8:32 PM, olcott wrote:
On 1/25/2023 7:18 PM, Python wrote:
Le 26/01/2023 Ã 01:54, olcott a Ã©critÂ :
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of >>>>>>>>> finite
strings into those that represent machines would halt on their >>>>>>>>> input
when directly executed and those that do not
So at least you admit that there no program can be written that >>>>>>>> is an halt decider! It took time for you to abandon your delusions! >>>>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement. >>>>>>
*This makes the current definition of the halting problem ill-defined* >>>>> Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations, >>>>> Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
Either a program stops or not. This is not ill-defined at all.
The problem of defining a machine that correctly determines whether or
not any arbitrary pair of finite strings represents a halting
computation or not can be solved by a simulating halt decider.
But it isn't a problem of the type described.
The Halting Problem does NOT start for a specified initial state, and
end in another specified final state, and there is not a specifically
listed set of operations allowed (just that it must use a computation).
Initial state or starting position: (start state of decider)
the allowable operations:
Â H simulates an input finite string pair (D,I) until the behavior of D
Â (a) Matches a non-halting behavior pattern (H aborts and rejects)
Â (b) Reaches its own final state (H accepts)
the goal state: (accept or reject state of decider)
On 1/25/23 8:41 PM, olcott wrote:
On 1/25/2023 7:09 PM, Richard Damon wrote:
On 1/25/23 7:54 PM, olcott wrote:
On 1/25/2023 6:48 PM, Python wrote:
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of finite >>>>>>>> strings into those that represent machines would halt on their >>>>>>>> input
when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions! >>>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement. >>>>>
*This makes the current definition of the halting problem ill-defined*
Not by the definition of Conputation theory
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations,
Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
Which is from a different field with different definition.
They are talking about PUZZLES as "Problems".
You are just showing your ignorance of the topic, an ignorance you
imposed on yourself by refusing to actually trying to learn any of
the topic (or being unable due to mental definciencies)
They are merely saying what I have been saying all along yet applying it
simultaneously to all fields.
Nope, it is SPECIFICALLY talking about "Problems" defined as figuring
out what sequence of transformations from a defined list will take you
from the specified inital state to a specified final state.
That isn't the type of "Problem" that the Halting Problem is.
On 1/25/2023 8:03 PM, Richard Damon wrote:
On 1/25/23 8:41 PM, olcott wrote:
On 1/25/2023 7:09 PM, Richard Damon wrote:
On 1/25/23 7:54 PM, olcott wrote:
On 1/25/2023 6:48 PM, Python wrote:Not by the definition of Conputation theory
Le 26/01/2023 Ã 01:40, olcott a Ã©critÂ :
On 1/25/2023 6:05 PM, Python wrote:
Peter Olcott wrote:
...
No machine can possibly be defined that divides all pairs of >>>>>>>>> finite
strings into those that represent machines would halt on their >>>>>>>>> input
when directly executed and those that do not
So at least you admit that there no program can be written that >>>>>>>> is an halt decider! It took time for you to abandon your delusions! >>>>>>>>
*I didn't say that*
This is exactly what you wrote. For once it was a correct statement. >>>>>>
*This makes the current definition of the halting problem ill-defined* >>>>
Â Â Â In the study of problem solving, any problem in which the
Â Â Â initial state or starting position, the allowable operations, >>>>> Â Â Â and the goal state are clearly specified, and a unique
Â Â Â solution can be shown to exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
Which is from a different field with different definition.
They are talking about PUZZLES as "Problems".
You are just showing your ignorance of the topic, an ignorance you
imposed on yourself by refusing to actually trying to learn any of
the topic (or being unable due to mental definciencies)
They are merely saying what I have been saying all along yet applying it >>> simultaneously to all fields.
Nope, it is SPECIFICALLY talking about "Problems" defined as figuring
out what sequence of transformations from a defined list will take you
from the specified inital state to a specified final state.
Yes and you fail to see that this is exactly a decision problem? https://en.wikipedia.org/wiki/Decision_problem
That isn't the type of "Problem" that the Halting Problem is.If you were correct (you are not correct) that would make the
halting problem ill-defined for more than one reason.
A halt decider begins at its own start state and transforms an arbitrary finite string pair input into a Boolean value indicated by its final
accept or reject state on the basis of whether or not the first element
of this pair would ever reach its own final state.
On 1/25/23 8:44 PM, olcott wrote:
On 1/25/2023 7:32 PM, Richard Damon wrote:
On 1/25/23 8:23 PM, olcott wrote:
On 1/25/2023 7:06 PM, Ben Bacarisse wrote:
Python <python@invalid.org> writes:
Peter Olcott wrote:Not so fast!Â Remember that PO is often fractally wrong.Â Not only >>>>> is he
...
No machine can possibly be defined that divides all pairs of finite >>>>>>> strings into those that represent machines would halt on their input >>>>>>> when directly executed and those that do not
So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions! >>>>>
usually wrong about the big picture he's usually wrong about all the >>>>> details too.Â In this case, he's having trouble expressing what he
means.Â This is actually just another iteration of his "it's an
invalid
question" stance, badly phrased.
*This time www.oxfordreference.com agrees*
Â Â Â In the study of problem solving, any problem in which the initial >>>> Â Â Â state or starting position, the allowable operations, and the goal >>>> Â Â Â state are clearly specified, and a unique solution can be shown to >>>> Â Â Â exist.
*a unique solution can be shown to exist* or the problem itself is
ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
But using the definitions of a DIFFERENT Field.
Their statement universally applies to all problems including decision
problems. I have known this all along, finally the rest of the world is
beginning to catch up.
How?
it specificially talks about problems based on starting at a specified initial state and getting to a specified final state, using a sequence
of transfomation from a defined set.
On 1/25/2023 8:06 PM, Richard Damon wrote:
How?
it specificially talks about problems based on starting at a specified
initial state and getting to a specified final state, using a sequence
of transfomation from a defined set.
That very obviously includes decision problems https://en.wikipedia.org/wiki/Decision_problem
Le 26/01/2023 à 01:33, Richard Damon a écrit :
One simple comment that comes to mind that points out the error in your
thinking:
The number of possible computing machines is a countable infinite,
because we can express every such machine as a finite string of a
finite symbol set.
The number of possible deciders that can be defined is an UNCOUNTABLE
infinite.
Thus, there are deciders that can not be computed, in
fact, MOST deciders can't be computed. (Admittedly a randomly chosen
decider likely isn't useful).
I suspect you aren't going to understand this, as you can't seem to
handle the actual concept of infinity.
Exactly. This is something Ben Bacarisse pointed out several times
here. Then the fact there is no program being an Halt Decider is
not much a surprise. It is only the first of this kind of problem that
has been found not to be able to be solve by a program.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 365 |
Nodes: | 16 (0 / 16) |
Uptime: | 11:16:16 |
Calls: | 7,758 |
Calls today: | 1 |
Files: | 12,897 |
Messages: | 5,744,645 |