On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph
looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph
looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in
this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
Professor Sipser has not had the time to carefully review this paper
presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this?
Yes.
Would Professor Sipser agree that you have refuted his halting problem
proof?
If I understand this correctly, it does not support the idea that a
general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let H be
an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get bored,
which won't take long (one iteration, two iterations, three iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will never
halt, abort the simulation, and report that it never halts. It wouldn't
be difficult to automate the process in a way that works for this simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable. Refuting the halting problem itself
has never been in scope.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD) does correctly determine that its input DD
would never stop running unless aborted.
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>> looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph
looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in
this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
Professor Sipser has not had the time to carefully review this paper >>>>> presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this?
Yes.
Would Professor Sipser agree that you have refuted his halting problem >>>> proof?
If I understand this correctly, it does not support the idea that a
general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let H be >>>> an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get bored, >>>> which won't take long (one iteration, two iterations, three iterations, >>>> zzzzzzzzz). I can, while simulating it, conclude that it will never
halt, abort the simulation, and report that it never halts. It
wouldn't
be difficult to automate the process in a way that works for this
simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you can hope
is to construct an oracle that can do what a Turing machine cannot do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>> looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph
looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in
this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
Professor Sipser has not had the time to carefully review this paper >>>>> presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this?
Yes.
Would Professor Sipser agree that you have refuted his halting problem >>>> proof?
If I understand this correctly, it does not support the idea that a
general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let H be >>>> an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get bored, >>>> which won't take long (one iteration, two iterations, three iterations, >>>> zzzzzzzzz). I can, while simulating it, conclude that it will never
halt, abort the simulation, and report that it never halts. It wouldn't >>>> be difficult to automate the process in a way that works for this simple >>>> case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you can hope
is to construct an oracle that can do what a Turing machine cannot do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
On 5/14/2025 2:15 AM, Mikko wrote:
On 2025-05-13 13:58:09 +0000, olcott said:
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>> looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>> looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in >>>>>>> this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof >>>>>>>
Professor Sipser has not had the time to carefully review this paper >>>>>>> presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this?
Yes.
Would Professor Sipser agree that you have refuted his halting
problem
proof?
If I understand this correctly, it does not support the idea that a >>>>>> general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let >>>>>> H be
an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get
bored,
which won't take long (one iteration, two iterations, three
iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will never >>>>>> halt, abort the simulation, and report that it never halts. It
wouldn't
be difficult to automate the process in a way that works for this
simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you can
hope
is to construct an oracle that can do what a Turing machine cannot
do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
As that does not identify any error in any proof it does not matter
whether that is noticed or not. What is soundly proven impossible
is impossible.
It is an error in the foundational basis of the proof.
When we assume that input DD can actually do the opposite
of whatever value that HHH reports then no HHH can correctly
report on the behavior of DD.
No such DD can possibly exist.
On 5/14/2025 2:15 AM, Mikko wrote:
On 2025-05-13 13:58:09 +0000, olcott said:
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>> looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>> looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in >>>>>>> this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof >>>>>>>
Professor Sipser has not had the time to carefully review this paper >>>>>>> presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this?
Yes.
Would Professor Sipser agree that you have refuted his halting problem >>>>>> proof?
If I understand this correctly, it does not support the idea that a >>>>>> general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let H be >>>>>> an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get bored, >>>>>> which won't take long (one iteration, two iterations, three iterations, >>>>>> zzzzzzzzz). I can, while simulating it, conclude that it will never >>>>>> halt, abort the simulation, and report that it never halts. It wouldn't
be difficult to automate the process in a way that works for this simple >>>>>> case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you can hope >>>> is to construct an oracle that can do what a Turing machine cannot do. It >>>> would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
As that does not identify any error in any proof it does not matter
whether that is noticed or not. What is soundly proven impossible
is impossible.
It is an error in the foundational basis of the proof.
When we assume that input DD can actually do the opposite
of whatever value that HHH reports then no HHH can correctly
report on the behavior of DD.
No such DD can possibly exist.
On 5/15/2025 1:55 AM, Mikko wrote:
On 2025-05-14 14:55:02 +0000, olcott said:
On 5/14/2025 2:15 AM, Mikko wrote:
On 2025-05-13 13:58:09 +0000, olcott said:
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>>>> looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>> looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in >>>>>>>>> this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof >>>>>>>>>
Professor Sipser has not had the time to carefully review this paper >>>>>>>>> presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this? >>>>>>>>>Yes.
Would Professor Sipser agree that you have refuted his halting problem >>>>>>>> proof?
If I understand this correctly, it does not support the idea that a >>>>>>>> general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let H be
an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get bored,
which won't take long (one iteration, two iterations, three iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will never >>>>>>>> halt, abort the simulation, and report that it never halts. It wouldn't
be difficult to automate the process in a way that works for this simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you can hope
is to construct an oracle that can do what a Turing machine cannot do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
As that does not identify any error in any proof it does not matter
whether that is noticed or not. What is soundly proven impossible
is impossible.
It is an error in the foundational basis of the proof.
When we assume that input DD can actually do the opposite
of whatever value that HHH reports then no HHH can correctly
report on the behavior of DD.
No. It does not point to a wrong word or clause or sentence in the
founcdational basis of the proof.
No such DD can possibly exist.
True but uninteresting. The important point is that no halt decider
exist. That a DD cannot be constructed from a non-existinghalt
decider is a rather obvious but not interesting.
There cannot possibly be any input D to a simulating
termination analyzer H that actually does the opposite
of whatever value that H returns.
On 5/15/2025 1:55 AM, Mikko wrote:
On 2025-05-14 14:55:02 +0000, olcott said:
On 5/14/2025 2:15 AM, Mikko wrote:
On 2025-05-13 13:58:09 +0000, olcott said:
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim
paragraph
looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>> looks correct:
If H does correctly determine that its correct simulation
of D would never stop running unless aborted, would it be
correct for H to abort this simulation and report that D
specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in >>>>>>>>> this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof >>>>>>>>>
Professor Sipser has not had the time to carefully review this >>>>>>>>> paper
presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this? >>>>>>>>>Yes.
Would Professor Sipser agree that you have refuted his halting >>>>>>>> problem
proof?
If I understand this correctly, it does not support the idea that a >>>>>>>> general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and >>>>>>>> let H be
an observer who attempts to determine whether or not D halts.
Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get >>>>>>>> bored,
which won't take long (one iteration, two iterations, three
iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will >>>>>>>> never
halt, abort the simulation, and report that it never halts. It >>>>>>>> wouldn't
be difficult to automate the process in a way that works for
this simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you
can hope
is to construct an oracle that can do what a Turing machine cannot >>>>>> do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
As that does not identify any error in any proof it does not matter
whether that is noticed or not. What is soundly proven impossible
is impossible.
It is an error in the foundational basis of the proof.
When we assume that input DD can actually do the opposite
of whatever value that HHH reports then no HHH can correctly
report on the behavior of DD.
No. It does not point to a wrong word or clause or sentence in the
founcdational basis of the proof.
No such DD can possibly exist.
True but uninteresting. The important point is that no halt decider
exist. That a DD cannot be constructed from a non-existinghalt
decider is a rather obvious but not interesting.
There cannot possibly be any input D to a simulating
termination analyzer H that actually does the opposite
of whatever value that H returns.
We can't even code an incorrect H this way because
no such D can possibly exist.
people talk about directly executed as if
int main()
{
DD();
}
The HHH called by DD can possibly report on the
behavior of its caller.
They never thought this through.
They all go by: The infallible word of textbook
says its so therefore it is true even when it is false.
On 5/16/2025 3:21 AM, Mikko wrote:
On 2025-05-16 02:48:07 +0000, olcott said:
On 5/15/2025 1:55 AM, Mikko wrote:
On 2025-05-14 14:55:02 +0000, olcott said:
On 5/14/2025 2:15 AM, Mikko wrote:
On 2025-05-13 13:58:09 +0000, olcott said:
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim >>>>>>>>>>>>> paragraph
looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim
paragraph
looks correct:
If H does correctly determine that its correct simulation >>>>>>>>>>> of D would never stop running unless aborted, would it be >>>>>>>>>>> correct for H to abort this simulation and report that D >>>>>>>>>>> specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider
referenced in
this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof >>>>>>>>>>>
Professor Sipser has not had the time to carefully review >>>>>>>>>>> this paper
presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this? >>>>>>>>>>>Yes.
Would Professor Sipser agree that you have refuted his halting >>>>>>>>>> problem
proof?
If I understand this correctly, it does not support the idea >>>>>>>>>> that a
general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and >>>>>>>>>> let H be
an observer who attempts to determine whether or not D halts. >>>>>>>>>> Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I >>>>>>>>>> get bored,
which won't take long (one iteration, two iterations, three >>>>>>>>>> iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will >>>>>>>>>> never
halt, abort the simulation, and report that it never halts. >>>>>>>>>> It wouldn't
be difficult to automate the process in a way that works for >>>>>>>>>> this simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you >>>>>>>> can hope
is to construct an oracle that can do what a Turing machine
cannot do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
As that does not identify any error in any proof it does not matter >>>>>> whether that is noticed or not. What is soundly proven impossible
is impossible.
It is an error in the foundational basis of the proof.
When we assume that input DD can actually do the opposite
of whatever value that HHH reports then no HHH can correctly
report on the behavior of DD.
No. It does not point to a wrong word or clause or sentence in the
founcdational basis of the proof.
No such DD can possibly exist.
True but uninteresting. The important point is that no halt decider
exist. That a DD cannot be constructed from a non-existinghalt
decider is a rather obvious but not interesting.
There cannot possibly be any input D to a simulating
termination analyzer H that actually does the opposite
of whatever value that H returns.
For every decider there is a D that actually does halt if the
decider rejects and funs forever if the decider accepts.
When you try to encode that in a language like
C you will find that has always been a false
assumption.
int main()
{
DD(); // HHH cannot report on the behavior of its caller
}
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 5/16/2025 3:21 AM, Mikko wrote:
On 2025-05-16 02:48:07 +0000, olcott said:
On 5/15/2025 1:55 AM, Mikko wrote:
On 2025-05-14 14:55:02 +0000, olcott said:
On 5/14/2025 2:15 AM, Mikko wrote:
On 2025-05-13 13:58:09 +0000, olcott said:
On 5/13/2025 2:46 AM, Mikko wrote:
On 2025-05-12 17:14:03 +0000, olcott said:
On 10/12/2022 6:49 PM, Keith Thompson wrote:
olcott <polcott2@gmail.com> writes:
On 10/12/2022 5:37 PM, Richard Damon wrote:
On 10/12/22 11:08 AM, olcott wrote:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>>>>>> looks correct:
<quoted email to professor Sipser>
Here is what I would like to say:
Professor Michael Sipser of MIT said that this verbatim paragraph >>>>>>>>>>> looks correct:
If H does correctly determine that its correct simulation >>>>>>>>>>> of D would never stop running unless aborted, would it be >>>>>>>>>>> correct for H to abort this simulation and report that D >>>>>>>>>>> specifies a non-halting sequence of configurations?
This validates the idea of a simulating halt decider referenced in >>>>>>>>>>> this paper.
Rebutting the Sipser Halting Problem Proof
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof >>>>>>>>>>>
Professor Sipser has not had the time to carefully review this paper
presented to him.
</quoted email to professor Sipser>
<quoted reply from professor Sipser>
Looks ok. Thanks for checking.
</quoted reply from professor Sipser>
IF I drop by and ask him face to face, will he confirm this? >>>>>>>>>>>Yes.
Would Professor Sipser agree that you have refuted his halting problem
proof?
If I understand this correctly, it does not support the idea that a >>>>>>>>>> general "simulating halt decider" can actually exist.
In the above, let D be a program that may or may not halt, and let H be
an observer who attempts to determine whether or not D halts. >>>>>>>>>> Concretely, let D be this C program or equivalent:
int main(void) { while (1) { } }
and I'll be H. I can observe D. I can simulate it until I get bored,
which won't take long (one iteration, two iterations, three iterations,
zzzzzzzzz). I can, while simulating it, conclude that it will never
halt, abort the simulation, and report that it never halts. It wouldn't
be difficult to automate the process in a way that works for this simple
case.
My scope is to prove that the "impossible"
input to all the halting problem proofs <is>
decidable.
As it is provably impossible it is not possible. The nearest you can hope
is to construct an oracle that can do what a Turing machine cannot do. It
would not be easy, just not yet proven imposssible.
Not at all. No one ever bothered to notice that
the contradictory part is unreachable code because
the counter-example input gets stuck in recursive
simulation. HHH simply sees this repeating pattern
and rejects DD.
As that does not identify any error in any proof it does not matter >>>>>> whether that is noticed or not. What is soundly proven impossible
is impossible.
It is an error in the foundational basis of the proof.
When we assume that input DD can actually do the opposite
of whatever value that HHH reports then no HHH can correctly
report on the behavior of DD.
No. It does not point to a wrong word or clause or sentence in the
founcdational basis of the proof.
No such DD can possibly exist.
True but uninteresting. The important point is that no halt decider
exist. That a DD cannot be constructed from a non-existinghalt
decider is a rather obvious but not interesting.
There cannot possibly be any input D to a simulating
termination analyzer H that actually does the opposite
of whatever value that H returns.
For every decider there is a D that actually does halt if the
decider rejects and funs forever if the decider accepts.
When you try to encode that in a language like
C you will find that has always been a false
assumption.
int main()
{
DD(); // HHH cannot report on the behavior of its caller
}
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 153:46:50 |
| Calls: | 10,383 |
| Files: | 14,054 |
| Messages: | 6,417,842 |