Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/ dp/113318779X
int DD()
 {
 int Halt_Status = HHH(DD);
 if (Halt_Status)
   HERE: goto HERE;
 return Halt_Status;
 }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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.
 </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>
Which is not what you thought he agreed to:
On Monday, March 6, 2023 at 2:41:27 PM UTC-5, Ben Bacarisse wrote:
I exchanged emails with him about this. He does not agree withanything
substantive that PO has written. I won't quote him, as I don't have
permission, but he was, let's say... forthright, in his reply to me.
*Ben already acknowledged that the requirements have been met*
On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
...D(D) would not halt unless H stops the simulation.
H /can/ correctly determine this silly criterion (in this one case)...
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing
about his knowledge and use of C. Yes, it's awful. He
knows very little C and the code is crap, but that/is/ a
straw man -- it's the simplest part of his argument to
fix.
Although it was an attempt to motivate him to improve the code,
it has become blindingly obvious that he's not interested,
which is precisely why I am going to stop bothering.
Do you really think that nit picky details
can refute the gist of what I am saying
that needs none of these details?
All of the conventional halting problem proofs
have several fatal flaws.
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report
on the actual behavior of non-terminating inputs
because this would cause themselves to never terminate.
They must always hypothesize what the behavior of the
input would be if they themselves never aborted.
False. They must always hypothesize what the behavior of
algorithm described by the input would be if it was executed
directly, as per the requirements:
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
There is no requirement that building a termination analyzer,
simulating or otherwise, is possible. In fact, it has proved to
not be possible by Linz and others, which you have *explicitly*
agreed with.
In other words you have no such actual reasoning.
The reasoning is that there is no requirement that building a
termination analyzer is possible.
So you have no actual reasoning that addresses my
actual point.
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
It makes sense because that's what's required to tell me if any
arbitrary algorithm X with input Y will halt when executed directly.
A simulating termination analyzer(STA) reports on
the behavior of the direct execution of the
algorithm specified by its input except in the
case where the input calls this STA to try to fool it.
What you are proposing would cause HHH to get stuck
in infinite execution. How is getting stuck in
infinite execution better than not getting stuck?
On 5/12/2025 9:58 PM, dbush wrote:
On 5/12/2025 10:46 PM, olcott wrote:
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report
on the actual behavior of non-terminating inputs
because this would cause themselves to never terminate.
They must always hypothesize what the behavior of the
input would be if they themselves never aborted.
False. They must always hypothesize what the behavior of >>>>>>>>>> algorithm described by the input would be if it was executed >>>>>>>>>> directly, as per the requirements:
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
There is no requirement that building a termination analyzer,
simulating or otherwise, is possible. In fact, it has proved to >>>>>>>> not be possible by Linz and others, which you have *explicitly* >>>>>>>> agreed with.
In other words you have no such actual reasoning.
The reasoning is that there is no requirement that building a
termination analyzer is possible.
So you have no actual reasoning that addresses my
actual point.
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
It makes sense because that's what's required to tell me if any
arbitrary algorithm X with input Y will halt when executed directly.
A simulating termination analyzer(STA) reports on
the behavior of the direct execution of the
algorithm specified by its input except in the
case where the input calls this STA to try to fool it.
What you are proposing would cause HHH to get stuck
in infinite execution. How is getting stuck in
infinite execution better than not getting stuck?
In other words, if you assume that a termination analyzer exists,
Unlike a halt decider that is either ALL KNOWING
or wrong a termination analyzer is correct even
if it can only compute the mapping from a single
input (that has no inputs) to the behavior that
this input specifies and thus its halt status.
HHH(DD) does correctly compute the mapping from its
input to the behavior that this input specifies.
HHH(DD) does not compute the mapping from its input
to BEHAVIOR THAT THIS INPUT DOES NOT SPECIFY.
The whole issue is that everyone here has been
indoctrinated into baselessly believing that
HHH should in some cases compute the mapping
to BEHAVIOR THAT THE INPUT DOES NOT SPECIFY.
No one can possibly provide any correct reasoning
why HHH must do this because no such correct
reasoning exists. On this issue it is merely
THAT IS NOT THE WAY THAT I MEMORIZED IT.
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>
Which your H doesn't do, as it can not correctly determine what
doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about his
knowledge and use of C. Yes, it's awful. He knows very little C and
the code is crap, but that/is/Â a straw man -- it's the simplest part of >>> his argument to fix.
Although it was an attempt to motivate him to improve the code, it has
become blindingly obvious that he's not interested, which is precisely
why I am going to stop bothering.
Do you really think that nit picky details
can refute the gist of what I am saying
that needs none of these details?
int DD()
 {
 int Halt_Status = HHH(DD);
 if (Halt_Status)
   HERE: goto HERE;
 return Halt_Status;
 }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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.
 </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 5/12/2025 10:14 PM, Richard Heathfield wrote:
On 13/05/2025 03:48, olcott wrote:
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about his
knowledge and use of C. Yes, it's awful. He
knows very little C and the code is crap, but that/is/Â a
straw man -- it's the simplest part of his argument to
fix.
Although it was an attempt to motivate him to improve the code, it
has become blindingly obvious that he's not interested, which is
precisely why I am going to stop bothering.
Do you really think that nit picky details
Are important? Yes.
Are important to you? No.
can refute the gist of what I am saying
No. If you won't listen to Alan Turing's refutation, you're sure as
hell not going to listen to mine.
All of the conventional halting problem proofs
have several fatal flaws. That you simply ignore
my proof of these fatal flaws is not actually
any rebuttal.
Every conventional halting problem proof has as
its most fundamental basis an input that can
actually do the opposite of whatever their
termination analyzer reports.
I prove this and you say blah blah blah but
Linz was right not paying any attention to
my proof of the fatal flaw and simply assuming
that I must be wrong about this.
All of the rebuttals of my work have as their
sole baseless basis that I must be wrong.
I must be wrong so let's see if the lame excuse
convinces him.
If the Goldbach conjecture is true (and there is
no short-cut) this requires testing against every
element of the set of natural numbers an infinite
computation.
*That had nothing to do with this point*
Exactly what actual reasoning shows that this
is superior to reporting on the behavior that
its input actual specifies?
If the Goldbach conjecture is true (and there is
no short-cut)
this requires testing against every
element of the set of natural numbers an infinite
computation.
On 5/13/2025 12:11 AM, Richard Heathfield wrote:Cool! What are those steps?
On 13/05/2025 03:01, olcott wrote:
I am refuting the key halting problem proof, I am not refuting thethis requires testing against every element of the set of natural
numbers an infinite computation.
Only if it's true. So if it's true, the testing program will never
halt.
But if it's false, the tester will eventually find the counter-example,
print it, and stop.
So a program that can tell whether another program will halt can tell
us whether Goldbach's conjecture is true.
It would be the short cut that you say doesn't exist.
halting problem.
As soon as it is understood that I am correct that HHH(DD) computes the mapping from its input to recursive emulation. Then in a few small steps
it will be know that I refuted the conventional Halting Problem proofs.
Am Tue, 13 May 2025 00:22:15 -0500 schrieb olcott:
On 5/13/2025 12:11 AM, Richard Heathfield wrote:
On 13/05/2025 03:01, olcott wrote:
Cool! What are those steps?I am refuting the key halting problem proof, I am not refuting thethis requires testing against every element of the set of natural
numbers an infinite computation.
Only if it's true. So if it's true, the testing program will never
halt.
But if it's false, the tester will eventually find the counter-example,
print it, and stop.
So a program that can tell whether another program will halt can tell
us whether Goldbach's conjecture is true.
It would be the short cut that you say doesn't exist.
halting problem.
As soon as it is understood that I am correct that HHH(DD) computes the
mapping from its input to recursive emulation. Then in a few small steps
it will be know that I refuted the conventional Halting Problem proofs.
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report on the >>>>>>>>> actual behavior of non-terminating inputs because this would >>>>>>>>> cause themselves to never terminate.
They must always hypothesize what the behavior of the input
would be if they themselves never aborted.
Because we are running the input directly. Imagine we have some serviceExactly what actual reasoning shows that this is superior to reportingIt makes sense because that's what's required to tell me if anyShow the actual reasoning of how it makes sense that a
simulating termination analyzer should ignore the behavior (to
its own peril) that the input actually specifies.
arbitrary algorithm X with input Y will halt when executed directly.
on the behavior that its input actual specifies?
Simulating Termination analyzers cannot possibly report on the actual behavior of non-terminating inputs because this would cause themselvesThere's nothing stopping HHH from aborting and still returning "halts".
to never terminate.
They must always hypothesize what the behavior of the input would be ifAnd if HHH were running indefinitely, it would halt.
they themselves never aborted.
On 5/12/2025 10:14 PM, Richard Heathfield wrote:
On 13/05/2025 03:48, olcott wrote:
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about his
knowledge and use of C. Yes, it's awful. He
knows very little C and the code is crap, but that/is/Â a
straw man -- it's the simplest part of his argument to
fix.
Although it was an attempt to motivate him to improve the code, it has >>>> become blindingly obvious that he's not interested, which is precisely >>>> why I am going to stop bothering.
Do you really think that nit picky details
Are important? Yes.
Are important to you? No.
can refute the gist of what I am saying
No. If you won't listen to Alan Turing's refutation, you're sure as
hell not going to listen to mine.
All of the conventional halting problem proofs
have several fatal flaws. That you simply ignore
my proof of these fatal flaws is not actually
any rebuttal.
On 5/12/2025 5:30 PM, dbush wrote:
On 5/12/2025 6:28 PM, olcott wrote:
On 5/12/2025 4:54 PM, dbush wrote:
On 5/12/2025 5:46 PM, olcott wrote:
On 5/12/2025 4:39 PM, dbush wrote:
On 5/12/2025 5:12 PM, olcott wrote:
On 5/12/2025 3:29 PM, dbush wrote:
On 5/12/2025 4:17 PM, olcott wrote:
On 5/12/2025 2:53 PM, dbush wrote:
On 5/12/2025 2:27 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition >>>>>>>>>>>>> by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation- Michael- >>>>>>>>>>>>> Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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. >>>>>>>>>>>>>   </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Which is not what you thought he agreed to:
On Monday, March 6, 2023 at 2:41:27 PM UTC-5, Ben Bacarisse wrote:
I exchanged emails with him about this. He does not agree with anything
substantive that PO has written. I won't quote him, as I don't have
permission, but he was, let's say... forthright, in his reply to me.
*Ben already acknowledged that the requirements have been met* >>>>>>>>>>>
On 10/17/2022 10:23 AM, Ben Bacarisse wrote:
...D(D) would not halt unless H stops the simulation. >>>>>>>>>>> Â > H /can/ correctly determine this silly criterion (in this one case)...
Which is not what Sipser agreed to, as stated above.
He agreed, as all others would, that H must determine if UTM(D) halts.
That is not what Ben's words mean.
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
I don't think that is the shell game. PO really /has/ an H >>>>>>>>> Â > (it's trivial to do for this one case) that correctly determines >>>>>>>>> Â > that P(P) *would* never stop running *unless* aborted.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>> Â Â Â Â H correctly determines that its simulated D
    would never stop running unless aborted...
*its simulated D*
Which Sipser (and everyone else) takes to mean UTM(D),
*its simulated D* cannot be *correctly* understood
to mean a D simulated by anything else other than
a hypothetical H that never aborts.
False. It cannot be *correctly* understood to be anything else but the >>>>>> algorithm D simulated completely by a UTM,
An H that never aborts <is> a UTM.
In which case you don't have algorithm D. You instead have algorithm Dn. >>>>
*its simulated D would never stop running unless aborted*
can only mean one thing.
And what it means is changing the input.
Changing the input is not allowed.
So professor Sisper was wrong?
On 5/12/2025 11:05 PM, Richard Damon wrote:
On 5/12/25 10:53 PM, olcott wrote:
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which your H doesn't do, as it can not correctly determine what
doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
Sure they can, since that is the truth, as explained.
Since your "logic" is based on lies and equivocation,
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:
*simulated D would never stop running unless aborted*
or they themselves could become non-terminating.
A rebuttal must take the form of another criteria
that prevents the simulating termination analyzer
from becoming non-terminating.
The lame rebuttals that I have been getting are
all of the form: "that is not the way that I memorized it."
On 5/12/2025 10:31 PM, dbush wrote:fails to see the halting behaviour.
On 5/12/2025 11:22 PM, olcott wrote:
On 5/12/2025 9:58 PM, dbush wrote:
On 5/12/2025 10:46 PM, olcott wrote:
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report >>>>>>>>>>>>> on the actual behavior of non-terminating inputs
because this would cause themselves to never terminate. >>>>>>>>>>>>>
They must always hypothesize what the behavior of the >>>>>>>>>>>>> input would be if they themselves never aborted.
False. They must always hypothesize what the behavior of >>>>>>>>>>>> algorithm described by the input would be if it was executed >>>>>>>>>>>> directly, as per the requirements:
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
There is no requirement that building a termination analyzer, >>>>>>>>>> simulating or otherwise, is possible. In fact, it has proved >>>>>>>>>> to not be possible by Linz and others, which you have
*explicitly* agreed with.
In other words you have no such actual reasoning.
The reasoning is that there is no requirement that building a
termination analyzer is possible.
So you have no actual reasoning that addresses my
actual point.
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
It makes sense because that's what's required to tell me if any
arbitrary algorithm X with input Y will halt when executed directly. >>>>>>
A simulating termination analyzer(STA) reports on
the behavior of the direct execution of the
algorithm specified by its input except in the
case where the input calls this STA to try to fool it.
What you are proposing would cause HHH to get stuck
in infinite execution. How is getting stuck in
infinite execution better than not getting stuck?
In other words, if you assume that a termination analyzer exists,
Unlike a halt decider that is either ALL KNOWING
or wrong a termination analyzer is correct even
if it can only compute the mapping from a single
input (that has no inputs) to the behavior that
this input specifies and thus its halt status.
False, as a universal termination analyzer must still answer for all
algorithms the following mapping:
You don't have the authority to rename elements of my work.
I chose termination analyzers intentionally avoiding the term
deciders. I don't want them to be universal.
Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
HHH(DD) does correctly compute the mapping from its
input to the behavior that this input specifies.
False, because it specifies the description of an algorithm that halts
when executed directly.
It may be very similar to the DD() that
halts but this different instance actually
EXECUTION TRACES DON'T LIE
On 5/13/2025 12:11 AM, Richard Heathfield wrote:
On 13/05/2025 03:01, olcott wrote:
If the Goldbach conjecture is true (and there is
no short-cut)
We don't know that. Fermat's Last Theorem had a short cut, but it took
358 years to find it. At that rate, we won't find Goldbach's short cut
(if it has one) for another 75 years.
this requires testing against every
element of the set of natural numbers an infinite
computation.
Only if it's true. So if it's true, the testing program will never
halt. But if it's false, the tester will eventually find the counter-
example, print it, and stop.
So a program that can tell whether another program will halt can tell
us whether Goldbach's conjecture is true.
It would be the short cut that you say doesn't exist.
I am refuting the key halting problem, proof
I am not refuting the halting problem.
As soon as it is understood that I am correct
that HHH(DD) computes the mapping from its
input to recursive emulation. Then in a few small
steps it will be know that I refuted the conventional
Halting Problem proofs.
On 5/12/2025 11:02 PM, Richard Damon wrote:
On 5/12/25 11:22 PM, olcott wrote:
On 5/12/2025 9:58 PM, dbush wrote:
On 5/12/2025 10:46 PM, olcott wrote:
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report >>>>>>>>>>>>> on the actual behavior of non-terminating inputs
because this would cause themselves to never terminate. >>>>>>>>>>>>>
They must always hypothesize what the behavior of the >>>>>>>>>>>>> input would be if they themselves never aborted.
False. They must always hypothesize what the behavior of >>>>>>>>>>>> algorithm described by the input would be if it was executed >>>>>>>>>>>> directly, as per the requirements:
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
There is no requirement that building a termination analyzer, >>>>>>>>>> simulating or otherwise, is possible. In fact, it has proved >>>>>>>>>> to not be possible by Linz and others, which you have
*explicitly* agreed with.
In other words you have no such actual reasoning.
The reasoning is that there is no requirement that building a
termination analyzer is possible.
So you have no actual reasoning that addresses my
actual point.
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
It makes sense because that's what's required to tell me if any
arbitrary algorithm X with input Y will halt when executed directly. >>>>>>
A simulating termination analyzer(STA) reports on
the behavior of the direct execution of the
algorithm specified by its input except in the
case where the input calls this STA to try to fool it.
What you are proposing would cause HHH to get stuck
in infinite execution. How is getting stuck in
infinite execution better than not getting stuck?
In other words, if you assume that a termination analyzer exists,
Unlike a halt decider that is either ALL KNOWING
or wrong a termination analyzer is correct even
if it can only compute the mapping from a single
input (that has no inputs) to the behavior that
this input specifies and thus its halt status.
Where od you get this from?
Just like Halt Deciders, a Complete Termination Analyser needs to
correctly answer for all input.
You don't seem to get tautologies so you
probably won't get this one.
All termination analyzers are correct (on this one input)
when they correctly determine the halt state of one input
with no inputs.
On the other hand a halt decider that gets one
input incorrectly is not a decider at all.
HHH(DD) does correctly compute the mapping from its
input to the behavior that this input specifies.
Nope, since DD Halts when run, and that is the DEFINITION of the
behavior the input sepecifies.
That is not the way that reality actually works.
HHH(DD) does not compute the mapping from its input
to BEHAVIOR THAT THIS INPUT DOES NOT SPECIFY.
No, you are claiming that it should, since the behavior it specifies
is the objective criteria of what the program it represents does when
run, which is halting.
The input to HHH(DD) specifies
recursive emulation.> The exact same string of machine code bytes asinput
to HHH1(DD) does
On 5/12/2025 11:05 PM, Richard Damon wrote:
On 5/12/25 10:53 PM, olcott wrote:
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which your H doesn't do, as it can not correctly determine what
doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
Sure they can, since that is the truth, as explained.
Since your "logic" is based on lies and equivocation,
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:
*simulated D would never stop running unless aborted*
or they themselves could become non-terminating.
A rebuttal must take the form of another criteria
that prevents the simulating termination analyzer
from becoming non-terminating.
The lame rebuttals that I have been getting are
all of the form: "that is not the way that I memorized it."
On 5/12/2025 11:02 PM, Richard Damon wrote:
On 5/12/25 11:22 PM, olcott wrote:
On 5/12/2025 9:58 PM, dbush wrote:
On 5/12/2025 10:46 PM, olcott wrote:
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report >>>>>>>>>>>>> on the actual behavior of non-terminating inputs
because this would cause themselves to never terminate. >>>>>>>>>>>>>
They must always hypothesize what the behavior of the >>>>>>>>>>>>> input would be if they themselves never aborted.
False. They must always hypothesize what the behavior of >>>>>>>>>>>> algorithm described by the input would be if it was executed >>>>>>>>>>>> directly, as per the requirements:
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
There is no requirement that building a termination analyzer, >>>>>>>>>> simulating or otherwise, is possible. In fact, it has proved >>>>>>>>>> to not be possible by Linz and others, which you have
*explicitly* agreed with.
In other words you have no such actual reasoning.
The reasoning is that there is no requirement that building a
termination analyzer is possible.
So you have no actual reasoning that addresses my
actual point.
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
It makes sense because that's what's required to tell me if any
arbitrary algorithm X with input Y will halt when executed directly. >>>>>>
A simulating termination analyzer(STA) reports on
the behavior of the direct execution of the
algorithm specified by its input except in the
case where the input calls this STA to try to fool it.
What you are proposing would cause HHH to get stuck
in infinite execution. How is getting stuck in
infinite execution better than not getting stuck?
In other words, if you assume that a termination analyzer exists,
Unlike a halt decider that is either ALL KNOWING
or wrong a termination analyzer is correct even
if it can only compute the mapping from a single
input (that has no inputs) to the behavior that
this input specifies and thus its halt status.
Where od you get this from?
Just like Halt Deciders, a Complete Termination Analyser needs to
correctly answer for all input.
You don't seem to get tautologies so you
probably won't get this one.
All termination analyzers are correct (on this one input)
when they correctly determine the halt state of one input
with no inputs.
On the other hand a halt decider that gets one
input incorrectly is not a decider at all.
HHH(DD) does correctly compute the mapping from its
input to the behavior that this input specifies.
Nope, since DD Halts when run, and that is the DEFINITION of the
behavior the input sepecifies.
That is not the way that reality actually works.
HHH(DD) does not compute the mapping from its input
to BEHAVIOR THAT THIS INPUT DOES NOT SPECIFY.
No, you are claiming that it should, since the behavior it specifies
is the objective criteria of what the program it represents does when
run, which is halting.
The input to HHH(DD) specifies recursive emulation.
The exact same string of machine code bytes as input
to HHH1(DD) does not specify recursive emulation.
We probably should stay with the one point until we
have complete closure.
On 5/12/2025 10:31 PM, dbush wrote:
On 5/12/2025 11:22 PM, olcott wrote:
On 5/12/2025 9:58 PM, dbush wrote:
On 5/12/2025 10:46 PM, olcott wrote:
On 5/12/2025 8:00 PM, dbush wrote:
On 5/12/2025 8:56 PM, olcott wrote:
On 5/12/2025 7:36 PM, dbush wrote:
On 5/12/2025 8:34 PM, olcott wrote:
On 5/12/2025 7:27 PM, dbush wrote:
On 5/12/2025 8:25 PM, olcott wrote:
On 5/12/2025 7:12 PM, dbush wrote:
On 5/12/2025 7:53 PM, olcott wrote:
Simulating Termination analyzers cannot possibly report >>>>>>>>>>>>> on the actual behavior of non-terminating inputs
because this would cause themselves to never terminate. >>>>>>>>>>>>>
They must always hypothesize what the behavior of the >>>>>>>>>>>>> input would be if they themselves never aborted.
False. They must always hypothesize what the behavior of >>>>>>>>>>>> algorithm described by the input would be if it was executed >>>>>>>>>>>> directly, as per the requirements:
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
There is no requirement that building a termination analyzer, >>>>>>>>>> simulating or otherwise, is possible. In fact, it has proved >>>>>>>>>> to not be possible by Linz and others, which you have
*explicitly* agreed with.
In other words you have no such actual reasoning.
The reasoning is that there is no requirement that building a
termination analyzer is possible.
So you have no actual reasoning that addresses my
actual point.
Show the actual reasoning of how it makes sense
that a simulating termination analyzer should
ignore the behavior (to its own peril) that the
input actually specifies.
It makes sense because that's what's required to tell me if any
arbitrary algorithm X with input Y will halt when executed directly. >>>>>>
A simulating termination analyzer(STA) reports on
the behavior of the direct execution of the
algorithm specified by its input except in the
case where the input calls this STA to try to fool it.
What you are proposing would cause HHH to get stuck
in infinite execution. How is getting stuck in
infinite execution better than not getting stuck?
In other words, if you assume that a termination analyzer exists,
Unlike a halt decider that is either ALL KNOWING
or wrong a termination analyzer is correct even
if it can only compute the mapping from a single
input (that has no inputs) to the behavior that
this input specifies and thus its halt status.
False, as a universal termination analyzer must still answer for all
algorithms the following mapping:
You don't have the authority to rename elements of my work.
I chose termination analyzers intentionally avoiding the term
deciders. I don't want them to be universal.
Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
HHH(DD) does correctly compute the mapping from its
input to the behavior that this input specifies.
False, because it specifies the description of an algorithm that halts
when executed directly.
It may be very similar to the DD() that
halts but this different instance actually
does not halt EXECUTION TRACES DON'T LIE
HHH(DD) does not compute the mapping from its input
to BEHAVIOR THAT THIS INPUT DOES NOT SPECIFY.
The whole issue is that everyone here has been
indoctrinated into baselessly believing that
HHH should in some cases compute the mapping
to BEHAVIOR THAT THE INPUT DOES NOT SPECIFY.
That's because if I want to know if any arbitrary algorithm X with
input Y will halt when executed directly, that requires an H that
meets these requirements, not your alternate requirements:
Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
No one can possibly provide any correct reasoning
why HHH must do this because no such correct
reasoning exists. On this issue it is merely
THAT IS NOT THE WAY THAT I MEMORIZED IT.
A LIE, as you were given numerous reasons below why this mapping is
useful and your alternate mapping is not useful, and your failure to
respond to this constitutes your acceptance of this fact.
On 5/12/2025 10:22 PM, dbush wrote:
On 5/12/2025 10:01 PM, olcott wrote:instructions) X
If the Goldbach conjecture is true (and there is;
no short-cut) this requires testing against every
element of the set of natural numbers an infinite
computation.
And if we take that computation and feed it into an H that meets these >> Â > requirements:
;
;
Given any algorithm (i.e. a fixed immutable sequence of
described as <X> with input Y:directly
;
A solution to the halting problem is an algorithm H that computes the
following mapping:
;
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
;if H
;
Then if H reports non-halting the Goldbach conjecture is true, and
reports halting the Goldbach conjecture is false.if it
;
If on the other hand we feed the computation to an H that tells us
"specifies non-halting behavior to H", we won't necessarily get thatWith
answer. We have to worry about how the computation is implemented.
the above requirements we don't need to worry about that.
;
The same applies to *any* process which may or may not be infinite to
tell us whether or not it is actually an infinite process.
On 5/12/2025 11:14 PM, Richard Damon wrote:
On 5/12/25 11:31 PM, olcott wrote:
On 5/12/2025 10:14 PM, Richard Heathfield wrote:
On 13/05/2025 03:48, olcott wrote:
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about
his knowledge and use of C. Yes, it's awful. He
knows very little C and the code is crap, but that/is/Â a
straw man -- it's the simplest part of his argument to
fix.
Although it was an attempt to motivate him to improve the code, it >>>>>> has become blindingly obvious that he's not interested, which is
precisely why I am going to stop bothering.
Do you really think that nit picky details
Are important? Yes.
Are important to you? No.
can refute the gist of what I am saying
No. If you won't listen to Alan Turing's refutation, you're sure as
hell not going to listen to mine.
All of the conventional halting problem proofs
have several fatal flaws. That you simply ignore
my proof of these fatal flaws is not actually
any rebuttal.
No, your "Proof" is full of fatal flaws, the first being you don't
even know the definiton of most of the terms you use.
Every conventional halting problem proof has as
its most fundamental basis an input that can
actually do the opposite of whatever their
termination analyzer reports.
WHich is what it does.
I proved that is impossible.
On 5/12/2025 11:11 PM, Richard Damon wrote:
On 5/12/25 10:48 PM, olcott wrote:
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about his
knowledge and use of C. Yes, it's awful. He knows very little C and >>>>> the code is crap, but that/is/ a straw man -- it's the simplest
part of
his argument to fix.
Although it was an attempt to motivate him to improve the code, it
has become blindingly obvious that he's not interested, which is
precisely why I am going to stop bothering.
Do you really think that nit picky details
can refute the gist of what I am saying
that needs none of these details?
Since you have yet to show that ANY of your claims are actually making
the point you want, you should be looking for small gains.
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
Which isn't a program that can be simulated until you pair it with the
HHH that it calls, and that will be a different program input for each
HHH that it pairs with.
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
So, you can prove that for HHH being a pure simulator, it won't reach
the end, but only after creating an input that calls that HHH, and
thus can't be decided on by any other HHH that you can think of.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>
Yes, *THAT* HHH is allowed to abort, but only because it doesn't.
This only has one meaning.
*its simulated D would never stop running unless aborted*
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about his
knowledge and use of C. Yes, it's awful. He knows very little C and
the code is crap, but that/is/Â a straw man -- it's the simplest part of >>> his argument to fix.
Although it was an attempt to motivate him to improve the code, it has
become blindingly obvious that he's not interested, which is precisely
why I am going to stop bothering.
Do you really think that nit picky details
can refute the gist of what I am saying
that needs none of these details?
On 5/13/2025 6:43 AM, Richard Damon wrote:...the simulating HHH, but not the simulatED one.
On 5/13/25 12:52 AM, olcott wrote:
In other words every single byte of HHH and DD are 100% totallyIt is truism that simulating termination analyzers must report on the
behavior of their input as if they themselves never aborted this
simulation:
Right, of the input actually given to them, which must include all
their code, and that code is what is actually there, not created by
this imaginary operation.
identical except the hypothetical HHH has its abort code commented out.
Uh yes it is supposed to be the same actual input. The *simulator* is hypothetical.But you aren't simulating the same PROGRAM D that the original wasIt is not supposed to be the same program. *simulated D would never stop running* refers to a different HHH/DD pair
given.
On 5/13/2025 6:43 AM, Richard Damon wrote:
On 5/13/25 12:52 AM, olcott wrote:
On 5/12/2025 11:05 PM, Richard Damon wrote:
On 5/12/25 10:53 PM, olcott wrote:
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which your H doesn't do, as it can not correctly determine what
doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
Sure they can, since that is the truth, as explained.
Since your "logic" is based on lies and equivocation,
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.
I hae.
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:
Right, of the input actually given to them, which must include all
their code, and that code is what is actually there, not created by
this imaginary operation.
In other words every single byte of HHH and DD are
100% totally identical except the hypothetical HHH
has its abort code commented out.
Thus, a HHH that aborts to return an answer, when looking at the DDD
that calls it, must look at the unaborted emulation of THAT DDD, that
calls the HHH that DOES abort and return an answer, as that is what
the PROGRAM DDD is, If you can not create the HHH that does that
without changing that input, that is a flaw in your system, not the
problem.
*simulated D would never stop running unless aborted*
or they themselves could become non-terminating.
But you aren't simulating the same PROGRAM D that the original was given.
It is not supposed to be the same program.
*simulated D would never stop running*
refers to a different HHH/DD pair
It is a hypothetical HHH/DD pair where everything
is exactly the same except that HHH has no abort
code.
Ben freaked out that professor Sipser agreed
to my use of the term *would* in
*simulated D would never stop running*
and said that he thought I tricked professor Sipser.
This is all still there in newsgroup servers
that don't keep deleting older messages.
On 5/13/2025 4:39 PM, joes wrote:
Am Tue, 13 May 2025 16:30:20 -0500 schrieb olcott:
On 5/13/2025 6:43 AM, Richard Damon wrote:...the simulating HHH, but not the simulatED one.
On 5/13/25 12:52 AM, olcott wrote:
In other words every single byte of HHH and DD are 100% totallyIt is truism that simulating termination analyzers must report on the >>>>> behavior of their input as if they themselves never aborted this
simulation:
Right, of the input actually given to them, which must include all
their code, and that code is what is actually there, not created by
this imaginary operation.
identical except the hypothetical HHH has its abort code commented out.
Uh yes it is supposed to be the same actual input. The *simulator* isBut you aren't simulating the same PROGRAM D that the original wasIt is not supposed to be the same program. *simulated D would never stop >>> running* refers to a different HHH/DD pair
given.
hypothetical.
HHH is supposed to report on the behavior that
*would* happen if this HHH never aborted its input.
It must always use that measure to make sure
that itself halts.
On 5/13/2025 6:46 AM, Richard Damon wrote:
On 5/13/25 12:41 AM, olcott wrote:
On 5/12/2025 11:11 PM, Richard Damon wrote:
On 5/12/25 10:48 PM, olcott wrote:
On 5/12/2025 9:26 PM, Richard Heathfield wrote:
On 13/05/2025 00:58, Ben Bacarisse wrote:
On the other hand, you are spending a lot of time arguing about his >>>>>>> knowledge and use of C. Yes, it's awful. He knows very little C >>>>>>> and
the code is crap, but that/is/Â a straw man -- it's the simplest >>>>>>> part of
his argument to fix.
Although it was an attempt to motivate him to improve the code, it >>>>>> has become blindingly obvious that he's not interested, which is
precisely why I am going to stop bothering.
Do you really think that nit picky details
can refute the gist of what I am saying
that needs none of these details?
Since you have yet to show that ANY of your claims are actually
making the point you want, you should be looking for small gains.
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
Which isn't a program that can be simulated until you pair it with
the HHH that it calls, and that will be a different program input
for each HHH that it pairs with.
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
So, you can prove that for HHH being a pure simulator, it won't
reach the end, but only after creating an input that calls that HHH,
and thus can't be decided on by any other HHH that you can think of.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Yes, *THAT* HHH is allowed to abort, but only because it doesn't.
This only has one meaning.
*its simulated D would never stop running unless aborted*
Right, but not restricted to the partial simulation that H does,
You have to pay 100% complete attention to
ALL the words. By failing to do this your
rebuttals are dishonest.
Yes it *IS* so restricted.
*H correctly simulates its input D until*
it meas the actual CORRECT AND COMPLETE simulation of D would never
stop running.
By your definution, a decider can just stop at any point and say that
is all I can do, this isn't halting.
The problem is your system starts by breaking the rules, as you D
isn't a program as required, since you exclude the H it calls,
allowing you to try to get away with changing it, but all that does is
show you have always been a liar.
I am not the one that did not notice these
words that have been repeated for 2.5 years:
*H correctly simulates its input D until*
MEANS A PARTIAL SIMULATION OF EVERY NON-TERMINATING INPUT
On 5/13/2025 8:58 PM, dbush wrote:
Then maybe you should stop implying that Sipser agrees with the aboveI have the emails where he agreed that I could publish his agreement
when it's been proven on multiple occasions that he has not.
*That* is dishonest.
with those exact words. Ben also checked this and verified it.
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>
Which is not what you thought he agreed to:
People tried for more than a year to get away with
saying the DDD was not emulated by HHH correctly until
I stipulated that DDD is emulated by HHH according to
the rules of the x86 language. Then they shut up about
this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
*My reviewers have been dishonest about all of these things*
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
On 5/13/2025 6:33 AM, Fred. Zwarts wrote:
Op 13.mei.2025 om 06:52 schreef olcott:
On 5/12/2025 11:05 PM, Richard Damon wrote:
On 5/12/25 10:53 PM, olcott wrote:
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which your H doesn't do, as it can not correctly determine what
doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
Sure they can, since that is the truth, as explained.
Since your "logic" is based on lies and equivocation,
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.
That has been done hundreths of times.
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:
One of the things that have been shown to you to be wrong.
Repeating it can be interpreted as lying.
The report must be about the behaviour specified in the input,
including the code to abort, not about the behaviour specified in a
hypothetical other HHH that does not abort
A simulating termination analyzer according to this exact spec
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Derives the exact same behavior as the directly executed D()
except in the case where D calls H(D). The traditional way to
handle this case is: *I GIVE UP I HAVE NO IDEA* That is *NOT*
the best of all possible ways to handle that case.
On 5/13/2025 8:07 PM, dbush wrote:
On 5/13/2025 5:30 PM, olcott wrote:
On 5/13/2025 6:43 AM, Richard Damon wrote:
On 5/13/25 12:52 AM, olcott wrote:
On 5/12/2025 11:05 PM, Richard Damon wrote:
On 5/12/25 10:53 PM, olcott wrote:
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael- >>>>>>>>> Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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. >>>>>>>>>   </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>> 10/13/2022>
Which your H doesn't do, as it can not correctly determine what >>>>>>>> doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
Sure they can, since that is the truth, as explained.
Since your "logic" is based on lies and equivocation,
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.
I hae.
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:
Right, of the input actually given to them, which must include all
their code, and that code is what is actually there, not created by
this imaginary operation.
In other words every single byte of HHH and DD are
100% totally identical except the hypothetical HHH
has its abort code commented out.
In other words you changed the input.
Changing the input is not allowed.
Thus, a HHH that aborts to return an answer, when looking at the DDD
that calls it, must look at the unaborted emulation of THAT DDD,
that calls the HHH that DOES abort and return an answer, as that is
what the PROGRAM DDD is, If you can not create the HHH that does
that without changing that input, that is a flaw in your system, not
the problem.
*simulated D would never stop running unless aborted*
or they themselves could become non-terminating.
But you aren't simulating the same PROGRAM D that the original was
given.
It is not supposed to be the same program.
So you *explicitly* admit to changing the input.
The finite string of DD is specific sequence bytes.
The finite string of HHH is specific sequence bytes.
The hypothetical HHH that does not abort its input
cannot have input that has changed because it never
comes into actual existence.
*simulated D would never stop running unless aborted*
This proves your work has nothing to do with the halting problem.
When ZFC over-ruled naive set theory this caused
Russell's Paradox to cease to exist.
If you were just honest about the fact that you're not actually
working on the halting problem, no one would be giving you any trouble.
Equally we could say that ZFC was not working
on the actual Russell's Paradox.
What I am doing is the same thing that ZFC did.
ZFC did not figure out how to correctly define
a set of all sets that do not contain themselves.
Instead ZFC rejected the foundation upon which
RP was built. That is what I am doing.
On 5/13/2025 2:41 AM, Mikko wrote:
On 2025-05-12 18:17:37 +0000, olcott said:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
 {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
 }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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
This specifies two requirements:
1. H correctly simulates that part of the behaviour of D that starts
from the start of the execution and does not end before the second
requirement is satisfied.
2. H correctly determines that unsimulated part of the behaviour is
infinitely long.
The second reuirement is not satisfied when HHH analyses the above
DD.
In other words you believe that DD will halt
on its own without ever being aborted by HHH.
That is counter-factual.
_DD()
[00002133] 55        push ebp     ; housekeeping
[00002134] 8bec      mov ebp,esp  ; housekeeping
[00002136] 51        push ecx     ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
...
HHH determines that DD correctly simulated by
HHH keeps calling HHH(DD) until HHH aborts this
simulation and rejects DD.
On 5/13/2025 8:31 PM, dbush wrote:
On 5/13/2025 9:27 PM, olcott wrote:
On 5/13/2025 8:07 PM, dbush wrote:
On 5/13/2025 5:30 PM, olcott wrote:
On 5/13/2025 6:43 AM, Richard Damon wrote:
On 5/13/25 12:52 AM, olcott wrote:
On 5/12/2025 11:05 PM, Richard Damon wrote:
On 5/12/25 10:53 PM, olcott wrote:
On 5/12/2025 8:27 PM, Richard Damon wrote:
On 5/12/25 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-
Michael- Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
    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. >>>>>>>>>>>   </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
Which your H doesn't do, as it can not correctly determine >>>>>>>>>> what doesn't happen.
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
Sure they can, since that is the truth, as explained.
Since your "logic" is based on lies and equivocation,
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.
I hae.
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:
Right, of the input actually given to them, which must include all >>>>>> their code, and that code is what is actually there, not created
by this imaginary operation.
In other words every single byte of HHH and DD are
100% totally identical except the hypothetical HHH
has its abort code commented out.
In other words you changed the input.
Changing the input is not allowed.
Thus, a HHH that aborts to return an answer, when looking at the
DDD that calls it, must look at the unaborted emulation of THAT
DDD, that calls the HHH that DOES abort and return an answer, as
that is what the PROGRAM DDD is, If you can not create the HHH
that does that without changing that input, that is a flaw in your >>>>>> system, not the problem.
*simulated D would never stop running unless aborted*
or they themselves could become non-terminating.
But you aren't simulating the same PROGRAM D that the original was >>>>>> given.
It is not supposed to be the same program.
So you *explicitly* admit to changing the input.
The finite string of DD is specific sequence bytes.
Which includes the specific sequence of bytes that is the finite
string HHH
No it does not. A function calls is not macro inclusion.
The finite string of HHH is specific sequence bytes.
The hypothetical HHH that does not abort its input
cannot have input that has changed because it never
comes into actual existence.
But your HHH decides on that hypothetical non-input.
The whole point here is not to critique the words
that professor Sipser agreed to.
The whole point here is to determine whether or
not HHH meets this spec. It is a verified fact
that it does meet this spec.
You try to get away with changing the subject to
deflect attention away from this key verified fact.
*simulated D would never stop running unless aborted*
This proves your work has nothing to do with the halting problem.
When ZFC over-ruled naive set theory this caused
Russell's Paradox to cease to exist.
Not unless you can show how halt deciders can exist from the axioms of
computation theory.
If you were just honest about the fact that you're not actuallyEqually we could say that ZFC was not working
working on the halting problem, no one would be giving you any trouble. >>>
on the actual Russell's Paradox.
What I am doing is the same thing that ZFC did.
Unless you can prove that the following requirements can be met from
the axioms of computation theory, your argument has no basis.
ZFC ruled that the equivalent arguments from set theory WERE WRONG !
On 5/12/2025 1:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/
dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
On 5/12/2025 1:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/
dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correctOlcott tries to get away with a partial simulation, even when it has
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
On 5/13/2025 7:58 PM, dbush wrote:
On 5/13/2025 5:04 PM, olcott wrote:
On 5/13/2025 12:46 PM, Mike Terry wrote:
The global trace table does not record the simulation level for an
entry, so the matching process is agnostic when it comes to
simulation levels.  Also note there are many conditional branch
instructions in HHH which would prevent matches occuring if we were
to include HHH instructions in the examined trace!
Yes that is true. The program-under-test is not the test-program.
FALSE!!!!
It is *both* the test program *and* part of the program under test.
As such, it is not allowed to be changed for any reason, hypothetical
or otherwise.
When HHH is reporting on the behavior of the finite string of x86
machine code specified by DD,
i.e. the machine code of the function DD, the machine code of the
function HHH, and the machine code of everything that HHH calls down
to the OS leve.
*would never stop running unless aborted*
Thus meets this spec:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
On 5/13/2025 4:39 PM, joes wrote:Right, if *this* simulator never aborted simulating *that* HHH that DDD
Am Tue, 13 May 2025 16:30:20 -0500 schrieb olcott:HHH is supposed to report on the behavior that *would* happen if this
On 5/13/2025 6:43 AM, Richard Damon wrote:...the simulating HHH, but not the simulatED one.
On 5/13/25 12:52 AM, olcott wrote:
In other words every single byte of HHH and DD are 100% totallyIt is truism that simulating termination analyzers must report on
the behavior of their input as if they themselves never aborted this >>>>> simulation:
Right, of the input actually given to them, which must include all
their code, and that code is what is actually there, not created by
this imaginary operation.
identical except the hypothetical HHH has its abort code commented
out.
Uh yes it is supposed to be the same actual input. The *simulator* isBut you aren't simulating the same PROGRAM D that the original wasIt is not supposed to be the same program. *simulated D would never
given.
stop running* refers to a different HHH/DD pair
hypothetical.
HHH never aborted its input.
On 5/13/2025 8:07 PM, dbush wrote:*crickets.
On 5/13/2025 5:30 PM, olcott wrote:
On 5/13/2025 6:43 AM, Richard Damon wrote:
On 5/13/25 12:52 AM, olcott wrote:
If my logic was based on lies and equivocation then you could
provide actual reasoning that corrects my errors.
I hae.
They themselves, but not the HHH called by the input.It is truism that simulating termination analyzers must report on
the behavior of their input as if they themselves never aborted this >>>>> simulation:
Only the simulating one, not the one being simulated.Right, of the input actually given to them, which must include allIn other words every single byte of HHH and DD are 100% totally
their code, and that code is what is actually there, not created by
this imaginary operation.
identical except the hypothetical HHH has its abort code commented
out.
We can hypothesise anything we want.The finite string of DD is specific sequence bytes. The finite string ofBut you aren't simulating the same PROGRAM D that the original wasIt is not supposed to be the same program.
given.
So you *explicitly* admit to changing the input.
HHH is specific sequence bytes.
The hypothetical HHH that does not abort its input cannot have input
that has changed because it never comes into actual existence.
Not in naive set theory.This proves your work has nothing to do with the halting problem.When ZFC over-ruled naive set theory this caused Russell's Paradox to
cease to exist.
On 5/14/2025 3:17 AM, joes wrote:
Am Tue, 13 May 2025 21:43:32 -0500 schrieb olcott:
On 5/13/2025 8:58 PM, dbush wrote:
He agreed that I could publish this.I have the emails where he agreed that I could publish his agreement
with those exact words. Ben also checked this and verified it.
Please publish those instead of paraphrasing.
Ben checked with him at the time.
On 5/14/2025 1:37 PM, joes wrote:
Am Wed, 14 May 2025 10:06:02 -0500 schrieb olcott:
On 5/14/2025 3:17 AM, joes wrote:
Am Tue, 13 May 2025 21:43:32 -0500 schrieb olcott:
On 5/13/2025 8:58 PM, dbush wrote:
He agreed that I could publish this.I have the emails where he agreed that I could publish his
agreement
with those exact words. Ben also checked this and verified it.
Please publish those instead of paraphrasing.
Ben checked with him at the time.
Ok so you don't have mails. Ben does.
How the Hell did you misconstrue that Ben has emails
and I have emails into meaning that I don't have emails?
Am Wed, 14 May 2025 10:06:02 -0500 schrieb olcott:
On 5/14/2025 3:17 AM, joes wrote:
Am Tue, 13 May 2025 21:43:32 -0500 schrieb olcott:
On 5/13/2025 8:58 PM, dbush wrote:
He agreed that I could publish this.I have the emails where he agreed that I could publish his agreement
with those exact words. Ben also checked this and verified it.
Please publish those instead of paraphrasing.
Ben checked with him at the time.
Ok so you don't have mails. Ben does.
On 5/14/2025 1:56 PM, Richard Heathfield wrote:
Asked to publish, you didn't publish.
I published this back in 2022
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof_---_DD_correctly_reports_its_own_halt_status
On 5/14/2025 2:17 PM, Richard Heathfield wrote:
On 14/05/2025 20:02, olcott wrote:
On 5/14/2025 1:56 PM, Richard Heathfield wrote:
<snip>
Asked to publish, you didn't publish.
I published this back in 2022
https://www.researchgate.net/
publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof_--- _DD_correctly_reports_its_own_halt_status
joes: To save you the trouble, there's nothing there that looks
like an email. A quote from an email? Possibly. But you won't
find the actual email there, and thus no header information you
could verify.
I am not going to publish a private email
you freaking nitwit.
I published the words that he agreed to as I said that I did
in the linked paper.
On 5/14/2025 2:49 PM, Richard Heathfield wrote:
On 14/05/2025 20:21, olcott wrote:
you freaking nitwit.
Does your mother know you're online?
My mother passed away from a stroke in 2020.
On 5/14/2025 3:18 PM, Richard Heathfield wrote:
On 14/05/2025 21:00, olcott wrote:
On 5/14/2025 2:49 PM, Richard Heathfield wrote:
On 14/05/2025 20:21, olcott wrote:
<snip>
you freaking nitwit.
Does your mother know you're online?
My mother passed away from a stroke in 2020.
I'm sorry for your loss. Does your supervisor know you're online?
I retired seven years ago.
On 5/14/2025 2:17 PM, Richard Heathfield wrote:Yeah, so you don't have proof.
On 14/05/2025 20:02, olcott wrote:
On 5/14/2025 1:56 PM, Richard Heathfield wrote:
Asked to publish, you didn't publish.
I am not going to publish a private email you freaking nitwit.
I published the words that he agreed to as I said that I did in the
linked paper.
Am Wed, 14 May 2025 14:21:22 -0500 schrieb olcott:
On 5/14/2025 2:17 PM, Richard Heathfield wrote:
On 14/05/2025 20:02, olcott wrote:
On 5/14/2025 1:56 PM, Richard Heathfield wrote:
Asked to publish, you didn't publish.
I am not going to publish a private email you freaking nitwit.Yeah, so you don't have proof.
I published the words that he agreed to as I said that I did in the
linked paper.
On 5/14/2025 3:28 PM, joes wrote:
Am Wed, 14 May 2025 14:21:22 -0500 schrieb olcott:
On 5/14/2025 2:17 PM, Richard Heathfield wrote:Yeah, so you don't have proof.
On 14/05/2025 20:02, olcott wrote:
On 5/14/2025 1:56 PM, Richard Heathfield wrote:
Asked to publish, you didn't publish.
I am not going to publish a private email you freaking nitwit.
I published the words that he agreed to as I said that I did
in the
linked paper.
I do have proof.
Your statement is dishonest.
On 5/14/2025 11:44 AM, olcott wrote:
THE SPEC REQUIRES A PARTIAL SIMULATION OF SOME INPUTS.
Simulation is not a requirement, merely an implementation detail.
Mapping the halting function is the requirement:
YOU NITWIT !!!
Am Tue, 13 May 2025 21:43:32 -0500 schrieb olcott:
On 5/13/2025 8:58 PM, dbush wrote:
Then maybe you should stop implying that Sipser agrees with the aboveI have the emails where he agreed that I could publish his agreement
when it's been proven on multiple occasions that he has not.
*That* is dishonest.
with those exact words. Ben also checked this and verified it.
Please publish those instead of paraphrasing.
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a paraphrase that probably doesn't capture the full meaning; the full **quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
There is a slight mystery as to why Sipser would respond to PO at all rather than just ignore him, but hey, maybe Sipser is just a nice guy!
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a paraphrase that probably doesn't capture the full meaning; the full **quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims.
On 5/14/2025 6:00 AM, Richard Damon wrote:
On 5/14/25 12:28 AM, olcott wrote:
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
Where are they in the ACTUAL Spec?
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
My HHH and DDD do meet the above spec.
On 5/14/2025 3:17 AM, joes wrote:
Am Tue, 13 May 2025 21:43:32 -0500 schrieb olcott:
On 5/13/2025 8:58 PM, dbush wrote:
Then maybe you should stop implying that Sipser agrees with the aboveI have the emails where he agreed that I could publish his agreement
when it's been proven on multiple occasions that he has not.
*That* is dishonest.
with those exact words. Ben also checked this and verified it.
Please publish those instead of paraphrasing.
He agreed that I could publish this.
Ben checked with him at the time.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Ben Bacarisse <ben@bsb.me.uk> writes:
Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> 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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a
paraphrase that probably doesn't capture the full meaning; the full
**quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
It's certainly true that it can be taken to be a purely hypothetical
remark, but I suspect PO played a more subtle trick on the professor.
Nothing in the quote that PO presented states that D is special in any
particular way. If D is simply "its input" then the statement is simply
true of some inputs to H: those that can be determined to be non-halting
can be reported as such. There will be many such inputs if the
simulator is clever at detecting certain patterns.
But D and H are the names that Sipser uses in his book in his HP proof.
Was it made clear that D is not just the name of the input (as the first
few words of the quote might suggest) but is in fact one very specific
input constructed from H itself? I don't know, and I doubt we ever
will. If that was made clear, then PO should be saying that Sipser
agreed to more than just the quoted words and in that case I'd wager his
agreement was based on the hypothetical nature of the quote.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I am no expert, though I did teach this material in a CS degree course
for many years.
Richard (H) has reminded us about avoiding straw man arguments and to
instead address the strongest, clearest version of the point of view we
reject. PO is playing with this idea by constructing straw men to be
agreed with!. He spent years honing a sentence to express his position
until is was vague enough that someone important would agree with it.
PO should, however, have asked Sipser to agree with an honest and clear
statement of his (incorrect) views:
(a) That false (non-halting) is the correct result for some inputs that
represent halting computations.
(b) This is because, in the special case of a putative halt decider that
uses simulation, it is correct to report on what /would/ happen were the
simulation /not/ aborted.
(c) In the specific case where D is constructed from a simulating H in
the manner typically found in Halting Theorem proofs, H would then be
able to correctly report a result because H can detect that D halts only
because H has to stop simulating to report at all.
No one would agree to any of this, so PO must hide these points in some
sort of waffle or other. As I say, it took years to move from being
relatively clear to being vague enough to trick the professor. All of
(a), (b) and (c) can be found, in varying degrees of clarity, in PO's
posts of the last 20 years.
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims. I've seen a lot of time and
bandwidth expended on this one statement (that PO recently hasn't
even been quoting correctly).
I do not expect to make any progress in helping PO to see the light.
I'm just curious about this one statement and the reaction to it.
I am neither sufficiently qualified nor sufficiently motivated to
analyze the rest of PO's claims.
On 5/14/2025 9:08 PM, Mike Terry wrote:
On 15/05/2025 01:11, Keith Thompson wrote:>>
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims. I've seen a lot of time and
bandwidth expended on this one statement (that PO recently hasn't
even been quoting correctly).
I do not expect to make any progress in helping PO to see the light.
I'm just curious about this one statement and the reaction to it.
I am neither sufficiently qualified nor sufficiently motivated to
analyze the rest of PO's claims.
I made a post at around 00:36 saying what I suspect Sipser agreed to.
IOW how Sipser expected readers (PO included) to interpret the words.
*THOSE WORDS ONLY HAVE ONE CORRECT MEANING*
(I just noticed that today)
You were perfectly correct until you made the
statement that
On 5/14/2025 7:36 PM, Mike Terry wrote:
In the case of his HHH/DD, the simulated input
(DD) /does/ stop running if simulated far enough
Every HHH is identical except that the outermost
simulation reaches its abort criteria one whole
simulation before the next inner one.
This means that unless the outermost HHH aborts
then none of them do. HHH can not simply wait.
On 5/14/2025 9:22 PM, olcott wrote:
On 5/14/2025 9:08 PM, Mike Terry wrote:
On 15/05/2025 01:11, Keith Thompson wrote:>>
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims. I've seen a lot of time and
bandwidth expended on this one statement (that PO recently hasn't
even been quoting correctly).
I do not expect to make any progress in helping PO to see the light.
I'm just curious about this one statement and the reaction to it.
I am neither sufficiently qualified nor sufficiently motivated to
analyze the rest of PO's claims.
I made a post at around 00:36 saying what I suspect Sipser agreed to.
IOW how Sipser expected readers (PO included) to interpret the words.
*THOSE WORDS ONLY HAVE ONE CORRECT MEANING*
(I just noticed that today)
You were perfectly correct until you made the
statement that
On 5/14/2025 7:36 PM, Mike Terry wrote:
In the case of his HHH/DD, the simulated input
(DD) /does/ stop running if simulated far enough
Every HHH is identical except that the outermost
simulation reaches its abort criteria one whole
simulation before the next inner one.
This means that unless the outermost HHH aborts
then none of them do. HHH can not simply wait.
I have already gone over this 150 times in the last
three years.
On 5/14/2025 6:00 AM, Richard Damon wrote:
On 5/14/25 12:28 AM, olcott wrote:
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael- Sipser/ >>>>>>> dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>> Â Â Â Â 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.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
Where are they in the ACTUAL Spec?
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
My HHH and DDD do meet the above spec.
On 5/14/2025 3:46 PM, dbush wrote:
On 5/14/2025 11:16 AM, olcott wrote:
On 5/14/2025 7:26 AM, dbush wrote:
On 5/14/2025 12:28 AM, olcott wrote:
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael- Sipser/
dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>> Â Â Â Â 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. >>>>>>>>>   </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
The below is a non-response to the above. This constitutes your
admission that Sipser did not in fact agree with you, and the fact that >>>> you trimmed the below proof in your response is your further admission >>>> that you intent to continue to lie about it.
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
On Monday, March 6, 2023 at 2:41:27 PM UTC-5, Ben Bacarisse wrote: >>>>>> I exchanged emails with him about this. He does not agree with anything >>>>>> substantive that PO has written. I won't quote him, as I don't have >>>>>> permission, but he was, let's say... forthright, in his reply to me. >>>>
He did agree with these verbatim words. I have the emails
to prove it.
But not what you though he agreed to, as been proven multiple times:
The words that he agreed to only have a single
meaning as I proved above.
On 5/14/2025 9:32 AM, joes wrote:No, HHH must report on the behaviour specified in the actual input, not
Am Tue, 13 May 2025 20:27:54 -0500 schrieb olcott:
On 5/13/2025 8:07 PM, dbush wrote:*crickets.
On 5/13/2025 5:30 PM, olcott wrote:
On 5/13/2025 6:43 AM, Richard Damon wrote:
On 5/13/25 12:52 AM, olcott wrote:
If my logic was based on lies and equivocation then you could
provide actual reasoning that corrects my errors.
I hae.
They themselves, but not the HHH called by the input.It is truism that simulating termination analyzers must report on >>>>>>> the behavior of their input as if they themselves never aborted this >>>>>>> simulation:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
void DDD()
{
 HHH(DDD);
 return;
}
HHH(DDD) must report on what the behavior of DDD would
be if this same HHH never aborted.
On 5/14/2025 7:36 PM, Mike Terry wrote:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> Â Â Â Â Â 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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a
paraphrase that probably doesn't capture the full meaning; the full
**quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I doubt that Sipser would be using your interpretation, relying on a
false premise as a clever kind of logical loop-hole to basically fob
someone off.
There is a natural (and correct) statement that Sipser is far more
likely (I'd say) to have agreed to.
First you should understand the basic idea behind a "Simulating Halt
Decider" (*SHD*) that /partially/ simulates its input, while observing
each simulation step looking for certain halting/non-halting patterns
in the simulation. A simple (working) example here is an input which
goes into a tight loop. Going back to x86 world for this example, say
the input (program to be decided) contains
  Input Code
  Address    Instruction
  ...
  00400000   push ebp
  00400001   mov ebp,esp
  00400003   sub esp,+24
  00400006   jmp 00400006   ; <===  jump to this instruction >>   00400008   mov eax,[ebp+20]
  0040000b   mov ecx,[eax]
  ...
and during simulation, the SHD traces the computation steps, which
reach the jmp instruction. The observed simulated instruction trace
might be something like:
  Inst.Ptr   Instruction
  00400000   push ebp
  00400001   mov ebp,esp
  00400003   sub esp,+24
  00400006   jmp 00400006      [A]
  00400006   jmp 00400006
  00400006   jmp 00400006
  00400006   jmp 00400006
  00400006   jmp 00400006
  00400006   jmp 00400006
  ...
Clearly the SHD, observing the above, already has enough information
after seeing step [A] to conclude that its target is going into a
tight loop, and is never going to halt. It can stop simulating and
correctly decide "non-halting".
That is a valid design for a (partial) halt decider, and it is how an
SHD works. Sipser would be aware of this sort of approach, though
likely under some name other than "SHD".
Now when we look at PO's Sipser quote:
--------- Sipser quote -----
  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.
----------------------------
we can easily interpret that as saying exactly what I said a SHD does
above. It tells PO that in the tight loop example, H correctly
simulates as far as [A], at which point it correctly determines that
"its simulated input would never stop running unless aborted", so it
can decide "non-halting".
All correct and natural, and no deliberately false premises to mislead
PO.
All the above is correct.
PO's problem is his misinterpretation of "its simulated input would
never stop running unless aborted". In the case of his HHH/DD, the
simulated input (DD) /does/ stop running if simulated far enough,
Keith Thompson may be able to explain how you are wrong.
Let's move to this simpler example:
void DDD()
{
 HHH(DDD);
 return;
}
There is no point in the simulation of DDD by HHH
where DDD reaches its simulated "return" statement.
I will put it more formally for every natural number
N there exists no simulation of N steps of DDD
by HHH where DDD ever reaches its simulated
"return" statement.
On 5/14/2025 6:27 AM, Richard Damon wrote:
On 5/13/25 11:42 PM, olcott wrote:
On 5/12/2025 1:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
Right, "Correct Simulations" can never be partial.
Partial Simulations can be partial.
Deciders can use Partial Simulations, if they do it correctly.
But to do so, they need to show that the ACTUAL CORRECT SIMULATION of
this EXACT input, which needs to represent a PROGRAM, would never halt.
*That is not what these words say*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
*its simulated D would never stop running unless aborted*
void DDD()
{
 HHH(DDD);
 return;
}
You already admitted the simulated input to HHH(DDD)
*would never stop running unless aborted*
On 5/14/2025 10:06 PM, Richard Damon wrote:
On 5/14/25 10:22 PM, olcott wrote:
On 5/14/2025 9:08 PM, Mike Terry wrote:
On 15/05/2025 01:11, Keith Thompson wrote:>>
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims. I've seen a lot of time and
bandwidth expended on this one statement (that PO recently hasn't
even been quoting correctly).
I do not expect to make any progress in helping PO to see the light. >>>>> I'm just curious about this one statement and the reaction to it.
I am neither sufficiently qualified nor sufficiently motivated to
analyze the rest of PO's claims.
I made a post at around 00:36 saying what I suspect Sipser agreed
to. IOW how Sipser expected readers (PO included) to interpret the
words.
*THOSE WORDS ONLY HAVE ONE CORRECT MEANING*
(I just noticed that today)
You were perfectly correct until you made the
statement that
On 5/14/2025 7:36 PM, Mike Terry wrote:
In the case of his HHH/DD, the simulated input
(DD) /does/ stop running if simulated far enough
Every HHH is identical except that the outermost
simulation reaches its abort criteria one whole
simulation before the next inner one.
This means that unless the outermost HHH aborts
then none of them do. HHH can not simply wait.
So "Identical except ..." means Identical in your world?
If you knew about cooperative multi-tasking I could
explain it to you.
Since aborted emulations do not show what a correct emulation does,
and that is what BEHAVIOR is based on.
You are trying to get away with twisting the exact
meaning of these words. It took me two years to
write those words.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
HHH correctly simulates itself simulating DDD
On 5/14/2025 7:48 PM, Ben Bacarisse wrote:
Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims.
I thought I addressed that directly. Disconnected from the original
context, it can been seen as either a rather obvious true statement or
as a true hypothetical. The trouble is, there is no way to consider it
*in isolation* because the meaning of the words depends on context.
They do not depend on the context.
An
educated reader will read a "simulating halt decider" either as a
nonexistent entity or as a "best attempt" decider of some class of
cases.
Until they bother to read its precise specification.
Some particular readers will imbue the names H and D with a very
specific technical meaning. And any attempt to re-word it to arrive at
something every educated reader will accept as correct will render it
irrelevant to PO who only cares about one meaning he has given it.
Those words only have one meaning.
The 2.5 years that people have been trying to get
away with dishonest "interpretations" end today.
According to the exact meaning of the words of the
spec HHH does correctly reject the HP counter-example
input as non-halting.
On 5/14/2025 9:26 AM, joes wrote:
Am Tue, 13 May 2025 16:52:14 -0500 schrieb olcott:
On 5/13/2025 4:39 PM, joes wrote:Right, if *this* simulator never aborted simulating *that* HHH that DDD
Am Tue, 13 May 2025 16:30:20 -0500 schrieb olcott:HHH is supposed to report on the behavior that *would* happen if this
On 5/13/2025 6:43 AM, Richard Damon wrote:...the simulating HHH, but not the simulatED one.
On 5/13/25 12:52 AM, olcott wrote:
In other words every single byte of HHH and DD are 100% totallyIt is truism that simulating termination analyzers must report on >>>>>>> the behavior of their input as if they themselves never aborted this >>>>>>> simulation:
Right, of the input actually given to them, which must include all >>>>>> their code, and that code is what is actually there, not created by >>>>>> this imaginary operation.
identical except the hypothetical HHH has its abort code commented
out.
Uh yes it is supposed to be the same actual input. The *simulator* isBut you aren't simulating the same PROGRAM D that the original was >>>>>> given.It is not supposed to be the same program. *simulated D would never
stop running* refers to a different HHH/DD pair
hypothetical.
HHH never aborted its input.
calls, which does abort. They are 100% completely different, except for
everything apart from the abort. HHH should report on what an UTM would
do with DDD calling the aborting HHH, namely halt.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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 correctly simulates its input D*
HHH simulates its input DDD according to the rules
of the x86 language
*until H correctly determines*
This requires a partial simulation of non-terminating inputs.
*its simulated D would never stop running unless aborted*
DDD simulated by a hypothetical HHH that never aborts
*would never stop running*
On 5/14/2025 6:43 PM, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
[...]
HHH does correctly simulate DDD until[...]
HHH correctly determines that its simulated DDD
would never stop running unless aborted.
And my understanding is that it is mathematically impossible for HHH
to do what you claim it does,
That is ridiculous as you already acknowledged.
void DDD()
{
 HHH(DDD);
 return;
}
It is dead obvious to any expert in C to correctly
determine that DDD cannot possibly stop running
when HHH is a pure simulator.
HHH merely needs to see this exact same DEAD OBVIOUS thing.
On 5/14/2025 6:24 AM, Fred. Zwarts wrote:
Op 14.mei.2025 om 06:28 schreef olcott:
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
Repeating false statements do not make them true, even when they are
true in your dreams.
It turns out that you do not understand the meaning of the words, such
as 'emulated correctly'
_DDD()
[00002172] 55        push ebp     ; housekeeping
[00002173] 8bec      mov ebp,esp  ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404Â Â Â Â add esp,+04
[00002182] 5d        pop ebp
[00002183] c3Â Â Â Â Â Â Â Â ret
Size in bytes:(0018) [00002183]
DDD correctly emulated by HHH means that
HHH emulates itself emulating DDD.
On 5/14/2025 6:19 AM, Fred. Zwarts wrote:Please cite the page of the specs of the x86 language where you read
Op 14.mei.2025 om 05:42 schreef olcott:
On 5/12/2025 1:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael-
Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
  </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
Olcott tried to get away by claiming that his simulator follows the
rules of the x86 language, but he ignores the proofs that the x86
language was violated with a premature abort.
*THE SPEC REQUIRES THIS PREMATURE ABORT*
On 5/14/2025 10:08 PM, Richard Damon wrote:
On 5/14/25 10:23 PM, olcott wrote:
On 5/14/2025 9:22 PM, olcott wrote:
On 5/14/2025 9:08 PM, Mike Terry wrote:
On 15/05/2025 01:11, Keith Thompson wrote:>>
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims. I've seen a lot of time and
bandwidth expended on this one statement (that PO recently hasn't
even been quoting correctly).
I do not expect to make any progress in helping PO to see the light. >>>>>> I'm just curious about this one statement and the reaction to it.
I am neither sufficiently qualified nor sufficiently motivated to
analyze the rest of PO's claims.
I made a post at around 00:36 saying what I suspect Sipser agreed
to. IOW how Sipser expected readers (PO included) to interpret the
words.
*THOSE WORDS ONLY HAVE ONE CORRECT MEANING*
(I just noticed that today)
You were perfectly correct until you made the
statement that
On 5/14/2025 7:36 PM, Mike Terry wrote:
In the case of his HHH/DD, the simulated input
(DD) /does/ stop running if simulated far enough
Every HHH is identical except that the outermost
simulation reaches its abort criteria one whole
simulation before the next inner one.
This means that unless the outermost HHH aborts
then none of them do. HHH can not simply wait.
I have already gone over this 150 times in the last
three years.
And it has been refuted nearly as many times, and the refutations
IGNORED, showing you have run out of ways to hide your error.
It has never been refuted because it is inherently true.
You just don't understand what the "behavior" of the input means,
The exact sequence of steps dumbo.
because you just belive your own lies, rather than the actual
definative definitions, because you can't stand rules.
It is simple software engineering that is just beyond you skill level.
On 5/14/2025 10:06 PM, Richard Damon wrote:
On 5/14/25 10:22 PM, olcott wrote:
On 5/14/2025 9:08 PM, Mike Terry wrote:
On 15/05/2025 01:11, Keith Thompson wrote:>>
Fair enough, but what I was trying to do in this instance was
to focus on the single statement that PO says Sipser agreed to.
PO complains, correctly or not, that nobody understands or
ackowledges the statement. I suggest that perhaps it's actually
a true statement *in isolation* (very roughly if a working halt
detector exists then it works as a halt detector), even though it
does not support PO's wider claims. I've seen a lot of time and
bandwidth expended on this one statement (that PO recently hasn't
even been quoting correctly).
I do not expect to make any progress in helping PO to see the light. >>>>> I'm just curious about this one statement and the reaction to it.
I am neither sufficiently qualified nor sufficiently motivated to
analyze the rest of PO's claims.
I made a post at around 00:36 saying what I suspect Sipser agreed
to. IOW how Sipser expected readers (PO included) to interpret the
words.
*THOSE WORDS ONLY HAVE ONE CORRECT MEANING*
(I just noticed that today)
You were perfectly correct until you made the
statement that
On 5/14/2025 7:36 PM, Mike Terry wrote:
In the case of his HHH/DD, the simulated input
(DD) /does/ stop running if simulated far enough
Every HHH is identical except that the outermost
simulation reaches its abort criteria one whole
simulation before the next inner one.
This means that unless the outermost HHH aborts
then none of them do. HHH can not simply wait.
So "Identical except ..." means Identical in your world?
If you knew about cooperative multi-tasking I could
explain it to you.
Since aborted emulations do not show what a correct emulation does,
and that is what BEHAVIOR is based on.
You are trying to get away with twisting the exact
meaning of these words. It took me two years to
write those words.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
HHH correctly simulates itself simulating DDD
On 5/15/2025 2:44 AM, Mikko wrote:
On 2025-05-14 15:55:58 +0000, olcott said:
On 5/14/2025 6:00 AM, Richard Damon wrote:
On 5/14/25 12:28 AM, olcott wrote:
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael- Sipser/
dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>> Â Â Â Â 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. >>>>>>>>>   </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
Where are they in the ACTUAL Spec?
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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
My HHH and DDD do meet the above spec.
That is not a spcification. That is a condition. Your HHH does not meet
that condition.
When anyone tries to show how my HHH does not
exactly conform to the exact meaning of the above
words THEY FIRST CHANGE THE WORDS. Richard has
been doing this for years.
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not agreed to anything else in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a
paraphrase that probably doesn't capture the full meaning; the full
**quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I doubt that Sipser would be using your interpretation, relying on a
false premise as a clever kind of logical loop-hole to basically fob
someone off.
On 5/15/2025 2:44 AM, Mikko wrote:
On 2025-05-14 15:55:58 +0000, olcott said:
On 5/14/2025 6:00 AM, Richard Damon wrote:
On 5/14/25 12:28 AM, olcott wrote:
On 5/13/2025 10:50 PM, dbush wrote:
On 5/13/2025 11:47 PM, olcott wrote:
On 5/12/2025 1:20 PM, dbush wrote:
On 5/12/2025 2:17 PM, olcott wrote:
Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars   568 rating
https://www.amazon.com/Introduction-Theory-Computation-Michael- >>>>>>>>> Sipser/ dp/113318779X
int DD()
  {
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
  }
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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. >>>>>>>>>   </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>> 10/13/2022>
Which is not what you thought he agreed to:
I have proven otherwise below:
And *yet again* you lie when definitive proof has been repeatedly
provided that he did not agree with out:
(the words only have one correct meaning)
*UNTIL YOU ADDRESS THESE POINTS THEY WILL BE ENDLESSLY REPEATED*
People tried for more than a year to get away with saying
that DDD was not emulated by HHH correctly until I stipulated
that DDD is emulated by HHH according to the rules of the
x86 language. Then they shut up about this.
People tried to get away with saying that HHH
cannot not decide halting on the basis of
*simulated D would never stop running unless aborted*
until I pointed out that those exact words are in the spec.
People tried to get away with saying that the correct
emulation of a non-halting input cannot be partial
Yet partial simulation is right in the spec:
*H correctly simulates its input D until*
Where are they in the ACTUAL Spec?
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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
My HHH and DDD do meet the above spec.
That is not a spcification. That is a condition. Your HHH does not meet
that condition.
When anyone tries to show how my HHH does not
exactly conform to the exact meaning of the above
words THEY FIRST CHANGE THE WORDS. Richard has
been doing this for years.
It was only yesterday that I first noticed that
my code has ALWAYS conformed to the exact meaning
of those words ever since I asked Professor Sipser
to look at those words.
I was fooled into trying to rebut Richard's now
dead obvious strawman error for 2.5 years.
A straw man fallacy (sometimes written as strawman)
is the informal fallacy of refuting an argument
different from the one actually under discussion https://en.wikipedia.org/wiki/Straw_man
On 5/15/2025 5:52 AM, Fred. Zwarts wrote:
Op 15.mei.2025 om 02:47 schreef olcott:
On 5/14/2025 7:36 PM, Mike Terry wrote:Only if you use for each N another input. But the input you used, as
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the >>>>> words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim >>>>>>> paragraph is correct (he has not agreed to anything else in this >>>>>>> paper):
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. >>>>>>> </Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a >>>>> paraphrase that probably doesn't capture the full meaning; the full
**quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I doubt that Sipser would be using your interpretation, relying on a
false premise as a clever kind of logical loop-hole to basically fob
someone off.
There is a natural (and correct) statement that Sipser is far more
likely (I'd say) to have agreed to.
First you should understand the basic idea behind a "Simulating Halt
Decider" (*SHD*) that /partially/ simulates its input, while
observing each simulation step looking for certain halting/non-
halting patterns in the simulation. A simple (working) example here
is an input which goes into a tight loop. Going back to x86 world
for this example, say the input (program to be decided) contains
  Input Code
  Address    Instruction
  ...
  00400000   push ebp
  00400001   mov ebp,esp
  00400003   sub esp,+24
  00400006   jmp 00400006   ; <===  jump to this instruction >>>>   00400008   mov eax,[ebp+20]
  0040000b   mov ecx,[eax]
  ...
and during simulation, the SHD traces the computation steps, which
reach the jmp instruction. The observed simulated instruction trace
might be something like:
  Inst.Ptr   Instruction
  00400000   push ebp
  00400001   mov ebp,esp
  00400003   sub esp,+24
  00400006   jmp 00400006      [A]
  00400006   jmp 00400006
  00400006   jmp 00400006
  00400006   jmp 00400006
  00400006   jmp 00400006
  00400006   jmp 00400006
  ...
Clearly the SHD, observing the above, already has enough information
after seeing step [A] to conclude that its target is going into a
tight loop, and is never going to halt. It can stop simulating and
correctly decide "non-halting".
That is a valid design for a (partial) halt decider, and it is how
an SHD works. Sipser would be aware of this sort of approach,
though likely under some name other than "SHD".
Now when we look at PO's Sipser quote:
--------- Sipser quote -----
  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. >>>> ----------------------------
we can easily interpret that as saying exactly what I said a SHD
does above. It tells PO that in the tight loop example, H correctly
simulates as far as [A], at which point it correctly determines that
"its simulated input would never stop running unless aborted", so it
can decide "non-halting".
All correct and natural, and no deliberately false premises to
mislead PO.
All the above is correct.
PO's problem is his misinterpretation of "its simulated input would
never stop running unless aborted". In the case of his HHH/DD, the
simulated input (DD) /does/ stop running if simulated far enough,
Keith Thompson may be able to explain how you are wrong.
Let's move to this simpler example:
void DDD()
{
  HHH(DDD);
  return;
}
There is no point in the simulation of DDD by HHH
where DDD reaches its simulated "return" statement.
I will put it more formally for every natural number
N there exists no simulation of N steps of DDD
by HHH where DDD ever reaches its simulated
"return" statement.
presented in Halt7.c, does not need an infinite number of steps.
You mislead yourself with the construction of DDD such that you think
that another HHH does not change the input.
Face the facts, not your dreams. Come out of rebuttal mode.
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides
a complete example of how this works.
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides
a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition 'correctly
simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
In addition, apparently you do not understand what I said, because you
do not bring anything against it.
I only address one point at a time because I found
that almost all of my reviewers get totally confused
even on one single point.
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides
a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition
'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this exact
input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
When you have any other process simulating D
then you are not referring to *its simulated D*
Mike already went through all of the details
of how this works perfectly well on conventional
inputs such as infinite loops.
*Click here to get the whole article*
https://al.howardknight.net/? STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides
a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition
'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this exact
input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program and
thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/? STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
PO's problem is his misinterpretation of "its simulated input would never stop running unless
aborted". In the case of his HHH/DD, the simulated input (DD) /does/ stop running if simulated far
enough, but HHH simply /doesn't/ go far enough because PO has mistakenly decided he's seen some
pattern that implies non-halting in the trace. [A pattern akin to the "tight loop" pattern, except
that the tight loop pattern is sound, while his pattern is unsound, matching on a halting input.
Simples!]
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>> Â Â Â Â 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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the >>>> words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim >>>>>> paragraph is correct (he has not agreed to anything else in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a
paraphrase that probably doesn't capture the full meaning; the full
**quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I doubt that Sipser would be using your interpretation, relying on a
false premise as a clever kind of logical loop-hole to basically fob
someone off.
The details of H are not known to Sipser, so he can't know whether a
premise is false. It is possible that some simulating partial decider
correctly simulates a part of the behaviour of some D and correctly
determines that the unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal loop. That
one premise is false about HHH with DDD is a part of what was asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides
a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition
'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this exact >>>>>> input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program and
thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the code
of the HHH it was built for, which is the HHH that aborts and returns 0.
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides
a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition
'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this exact >>>>>> input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program and
thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the code
of the HHH it was built for, which is the HHH that aborts and returns 0.
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
When you keep switching this back to
*WHAT HAPPENS WHEN DDD IS ABORTED*
You become a damned liar.
HHH and DDD and everything that HHH calls
*WOULD NEVER STOP RUNNING UNLESS DDD IS ABORTED*
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>> 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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of the >>>>> words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't
notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim >>>>>>> paragraph is correct (he has not agreed to anything else in this >>>>>>> paper):
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. >>>>>>> </Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a
paraphrase that probably doesn't capture the full meaning; the full
**quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is
that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I doubt that Sipser would be using your interpretation, relying on a false premise as a clever
kind of logical loop-hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know whether a
premise is false. It is possible that some simulating partial decider
correctly simulates a part of the behaviour of some D and correctly
determines that the unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal loop. That
one premise is false about HHH with DDD is a part of what was asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to derive
a correct Simulating Halt Decider form the exact meaning of any words.
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation of >>>>>> the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't >>>>>> notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim >>>>>>>> paragraph is correct (he has not agreed to anything else in this >>>>>>>> paper):
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. >>>>>>>> </Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a >>>>>> paraphrase that probably doesn't capture the full meaning; the full >>>>>> **quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is >>>>>> that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four
vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices, >>>>>> and in fact no such triangle exists. Similarly, *if* a general
halt decider existed, then there are a lot of things we could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any
actual experts in computational theory (not you, PO) to criticize
what I've written.
I doubt that Sipser would be using your interpretation, relying on
a false premise as a clever kind of logical loop-hole to basically
fob someone off.
The details of H are not known to Sipser, so he can't know whether a
premise is false. It is possible that some simulating partial decider
correctly simulates a part of the behaviour of some D and correctly
determines that the unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal loop. That
one premise is false about HHH with DDD is a part of what was asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to derive
a correct Simulating Halt Decider form the exact meaning of any words.
That's correct.
We could build a correct /partial/ SHD though, which I explained. The
idea behind an PSHD is ok, and a class of HP inputs could be correctly decided with a PSHD. Obviously a PSHD H could not decide its
corresponding H^ input, as the Linz HP proof implies. Since PO's HHH / does/ decide its corresponding DD (incorrectly), it is not a PSHD, since PSHDs are not allowed to decide incorrectly.  [A correctly coded PSHD
HHH would never halt when given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of Sipser's words. Sipser's words concern how a PSHD H could decide some FIXED
INPUT D it has been given. PO wants to interpret them as what happens
when H is modified, and D is also modified to reference the new H. So
he's modifying what is supposed to be a fixed input half way through his interpretation. Sipser would be holding his head in his hands if he
knew (and cared) ... :)
Mike.
On 5/17/2025 8:08 AM, Richard Damon wrote:
On 5/16/25 11:08 PM, olcott wrote:
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
    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. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides >>>>>>>>>>> a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition >>>>>>>>>> 'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this
exact input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program
and thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
Read all the message.
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the
code of the HHH it was built for, which is the HHH that aborts and
returns 0.
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
No, its job is to determine if the program that the input represents
will halt.
*THAT IS NOT WHAT THE ABOVE SPEC SAYS KNUCKLEHEAD*
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means:
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation
of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you didn't >>>>>>> notice. Here's the full quotation from a previous article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following
verbatim
paragraph is correct (he has not agreed to anything else in this >>>>>>>>> paper):
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. >>>>>>>>> </Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim,
**then** H can correctly report the halting status of D. (That's a >>>>>>> paraphrase that probably doesn't capture the full meaning; the full >>>>>>> **quotation is above.)
To put it another way, If H correctly simulated its input in
the manner you claim, then H could correctly report the halting
status of D.
I'm not surprised that Sipser would agree to that. The problem is >>>>>>> that it's a conditional statement whose premise is impossible.
If an equilateral triangle had four sides, then each of its four >>>>>>> vertices would be 90 degrees. That doesn't actually mean that
there exists an equilateral triangle with four 90-degree vertices, >>>>>>> and in fact no such triangle exists. Similarly, *if* a general >>>>>>> halt decider existed, then there are a lot of things we could say >>>>>>> about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any >>>>>>> actual experts in computational theory (not you, PO) to criticize >>>>>>> what I've written.
I doubt that Sipser would be using your interpretation, relying on >>>>>> a false premise as a clever kind of logical loop-hole to basically >>>>>> fob someone off.
The details of H are not known to Sipser, so he can't know whether a >>>>> premise is false. It is possible that some simulating partial decider >>>>> correctly simulates a part of the behaviour of some D and correctly
determines that the unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal loop. That >>>>> one premise is false about HHH with DDD is a part of what was asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to derive
a correct Simulating Halt Decider form the exact meaning of any words.
That's correct.
We could build a correct /partial/ SHD though, which I explained. The
idea behind an PSHD is ok, and a class of HP inputs could be correctly
decided with a PSHD. Obviously a PSHD H could not decide its
corresponding H^ input, as the Linz HP proof implies. Since PO's
HHH / does/ decide its corresponding DD (incorrectly), it is not a
PSHD, since PSHDs are not allowed to decide incorrectly. Â [A correctly
coded PSHD HHH would never halt when given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of Sipser's
words. Sipser's words concern how a PSHD H could decide some FIXED
INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better
than the next best reviewer. Mike is one of the few
people here that really wants an honest dialogue. He
carefully examined my code and has a nearly perfect
understanding.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal
at the expense of truth. Keith and Ben also seem to
care about truth.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   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
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/? STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Just like your SHD does not base its decision on the
actual behavior of the infinite loop after it has
aborted its simulation of this loop, instead it bases
its decision on a different H/D pair that never aborts.
HHH(DDD) does not base its decision on the actual
behavior of DDD after it has aborted its simulation
of DDD, instead it bases its decision on a different
HHH/DDD pair that never aborts.
If an otherwise correct SHD always reported on the
behavior of its input AFTER it aborts then every
input would be determined to be halting.
The key question here that most experts in the theory
of computation would be aware of is the way that functions
computed by models of computation must work.
Is HHH supposed to compute the mapping from its input
on the basis of the behavior specified by this input
or something else?
My presentation using the concrete language of x86 leaves
no doubt exactly what behavior that DDD specifies.
DDD correctly simulated by HHH
*would never stop running unless aborted*
PO wants to interpret them as what happens when H is modified, and D
is also modified to reference the new H. So he's modifying what is
supposed to be a fixed input half way through his interpretation.
Sipser would be holding his head in his hands if he knew (and
cared) ... :)
Mike.
On 5/17/2025 4:03 AM, Fred. Zwarts wrote:
Op 17.mei.2025 om 05:08 schreef olcott:
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
    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. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides >>>>>>>>>>> a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition >>>>>>>>>> 'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this
exact input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program
and thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the
code of the HHH it was built for, which is the HHH that aborts and
returns 0.
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
No, it is the task of HHH to determine whether *this* input, that
includes Halt7.c and which does specify a conditional abort, halts.
I am only asking DOES HHH meet the above spec?
You keep changing the subject away from this.
*This is an axiom of the above spec*
*WOULD NEVER STOP RUNNING UNLESS ABORTED*
When you disagree you change the subject
away from: DOES HHH meet the above spec?
Changing the subject is a favorite tactic
of my dishonest reviewers.
On 5/17/2025 2:54 PM, Richard Damon wrote:
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:Mike explains all of the details of exactly how a
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means: >>>>>>>>>>>
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>> 10/13/2022>
    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
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct interpretation >>>>>>>>> of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you >>>>>>>>> didn't
notice. Here's the full quotation from a previous article: >>>>>>>>>
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>> verbatim
paragraph is correct (he has not agreed to anything else in this >>>>>>>>>>> paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim, >>>>>>>>> **then** H can correctly report the halting status of D.
(That's a
paraphrase that probably doesn't capture the full meaning; the >>>>>>>>> full
**quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>> the manner you claim, then H could correctly report the halting >>>>>>>>> status of D.
I'm not surprised that Sipser would agree to that. The problem is >>>>>>>>> that it's a conditional statement whose premise is impossible. >>>>>>>>>
If an equilateral triangle had four sides, then each of its four >>>>>>>>> vertices would be 90 degrees. That doesn't actually mean that >>>>>>>>> there exists an equilateral triangle with four 90-degree vertices, >>>>>>>>> and in fact no such triangle exists. Similarly, *if* a general >>>>>>>>> halt decider existed, then there are a lot of things we could say >>>>>>>>> about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any >>>>>>>>> actual experts in computational theory (not you, PO) to criticize >>>>>>>>> what I've written.
I doubt that Sipser would be using your interpretation, relying >>>>>>>> on a false premise as a clever kind of logical loop-hole to
basically fob someone off.
The details of H are not known to Sipser, so he can't know whether a >>>>>>> premise is false. It is possible that some simulating partial
decider
correctly simulates a part of the behaviour of some D and correctly >>>>>>> determines that the unsimulated part of the behaviour never halts; >>>>>>> for example, if the unsimulated part is a trivial eternal loop. That >>>>>>> one premise is false about HHH with DDD is a part of what was asked. >>>>>>
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to
derive
a correct Simulating Halt Decider form the exact meaning of any words. >>>>>
That's correct.
We could build a correct /partial/ SHD though, which I explained.
The idea behind an PSHD is ok, and a class of HP inputs could be
correctly decided with a PSHD. Obviously a PSHD H could not decide
its corresponding H^ input, as the Linz HP proof implies. Since
PO's HHH / does/ decide its corresponding DD (incorrectly), it is
not a PSHD, since PSHDs are not allowed to decide incorrectly. Â [A
correctly coded PSHD HHH would never halt when given its (HHH^,HHH^)
input.
PO's problem is that he misunderstands the entire context of
Sipser's words. Sipser's words concern how a PSHD H could decide
some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better
than the next best reviewer. Mike is one of the few
people here that really wants an honest dialogue. He
carefully examined my code and has a nearly perfect
understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal
at the expense of truth. Keith and Ben also seem to
care about truth.
No, rebuttal for the SAKE of truth.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
On 5/17/2025 3:10 PM, Richard Damon wrote:
On 5/17/25 4:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means: >>>>>>>>>>>>>
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>>> 10/13/2022>
    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 >>>>>>>>>>>>>>
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct
interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you >>>>>>>>>>> didn't
notice. Here's the full quotation from a previous article: >>>>>>>>>>>
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>>> verbatim
paragraph is correct (he has not agreed to anything else in >>>>>>>>>>>>> this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim, >>>>>>>>>>> **then** H can correctly report the halting status of D. >>>>>>>>>>> (That's a
paraphrase that probably doesn't capture the full meaning; >>>>>>>>>>> the full
**quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>>> the manner you claim, then H could correctly report the halting >>>>>>>>>>> status of D.
I'm not surprised that Sipser would agree to that. The >>>>>>>>>>> problem is
that it's a conditional statement whose premise is impossible. >>>>>>>>>>>
If an equilateral triangle had four sides, then each of its four >>>>>>>>>>> vertices would be 90 degrees. That doesn't actually mean that >>>>>>>>>>> there exists an equilateral triangle with four 90-degree >>>>>>>>>>> vertices,
and in fact no such triangle exists. Similarly, *if* a general >>>>>>>>>>> halt decider existed, then there are a lot of things we could >>>>>>>>>>> say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any >>>>>>>>>>> actual experts in computational theory (not you, PO) to
criticize
what I've written.
I doubt that Sipser would be using your interpretation,
relying on a false premise as a clever kind of logical loop- >>>>>>>>>> hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know
whether a
premise is false. It is possible that some simulating partial >>>>>>>>> decider
correctly simulates a part of the behaviour of some D and
correctly
determines that the unsimulated part of the behaviour never halts; >>>>>>>>> for example, if the unsimulated part is a trivial eternal loop. >>>>>>>>> That
one premise is false about HHH with DDD is a part of what was >>>>>>>>> asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to >>>>>>> derive
a correct Simulating Halt Decider form the exact meaning of any
words.
That's correct.
We could build a correct /partial/ SHD though, which I explained.
The idea behind an PSHD is ok, and a class of HP inputs could be
correctly decided with a PSHD. Obviously a PSHD H could not
decide its corresponding H^ input, as the Linz HP proof implies.
Since PO's HHH / does/ decide its corresponding DD (incorrectly),
it is not a PSHD, since PSHDs are not allowed to decide
incorrectly. Â [A correctly coded PSHD HHH would never halt when
given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of
Sipser's words. Sipser's words concern how a PSHD H could decide >>>>>> some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better
than the next best reviewer. Mike is one of the few
people here that really wants an honest dialogue. He
carefully examined my code and has a nearly perfect
understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal
at the expense of truth. Keith and Ben also seem to
care about truth.
No, rebuttal for the SAKE of truth.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> Â Â Â Â 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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
Who is changing the subject, and how is it being changed?
When you say that I did not meet the spec
because I did not meet a requirement that
is not in the spec you are a damned liar.
On 5/17/2025 3:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means: >>>>>>>>>>>>
And since the DD that HHH is simulating WILL HALT when fully >>>>>>>>>>>>>> simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>> 10/13/2022>
    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 >>>>>>>>>>>>>
If that was actually true then you could provide an
alternative meaning for the exact words stated above.
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct
interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you >>>>>>>>>> didn't
notice. Here's the full quotation from a previous article: >>>>>>>>>>
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>> verbatim
paragraph is correct (he has not agreed to anything else in >>>>>>>>>>>> this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim, >>>>>>>>>> **then** H can correctly report the halting status of D.
(That's a
paraphrase that probably doesn't capture the full meaning; the >>>>>>>>>> full
**quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>> the manner you claim, then H could correctly report the halting >>>>>>>>>> status of D.
I'm not surprised that Sipser would agree to that. The
problem is
that it's a conditional statement whose premise is impossible. >>>>>>>>>>
If an equilateral triangle had four sides, then each of its four >>>>>>>>>> vertices would be 90 degrees. That doesn't actually mean that >>>>>>>>>> there exists an equilateral triangle with four 90-degree
vertices,
and in fact no such triangle exists. Similarly, *if* a general >>>>>>>>>> halt decider existed, then there are a lot of things we could say >>>>>>>>>> about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite any >>>>>>>>>> actual experts in computational theory (not you, PO) to criticize >>>>>>>>>> what I've written.
I doubt that Sipser would be using your interpretation, relying >>>>>>>>> on a false premise as a clever kind of logical loop-hole to
basically fob someone off.
The details of H are not known to Sipser, so he can't know
whether a
premise is false. It is possible that some simulating partial
decider
correctly simulates a part of the behaviour of some D and correctly >>>>>>>> determines that the unsimulated part of the behaviour never halts; >>>>>>>> for example, if the unsimulated part is a trivial eternal loop. >>>>>>>> That
one premise is false about HHH with DDD is a part of what was
asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to
derive
a correct Simulating Halt Decider form the exact meaning of any
words.
That's correct.
We could build a correct /partial/ SHD though, which I explained.
The idea behind an PSHD is ok, and a class of HP inputs could be
correctly decided with a PSHD. Obviously a PSHD H could not decide >>>>> its corresponding H^ input, as the Linz HP proof implies. Since
PO's HHH / does/ decide its corresponding DD (incorrectly), it is
not a PSHD, since PSHDs are not allowed to decide incorrectly. Â [A
correctly coded PSHD HHH would never halt when given its
(HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of
Sipser's words. Sipser's words concern how a PSHD H could decide
some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better
than the next best reviewer. Mike is one of the few
people here that really wants an honest dialogue. He
carefully examined my code and has a nearly perfect
understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal
at the expense of truth. Keith and Ben also seem to
care about truth.
No, rebuttal for the SAKE of truth.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
*H correctly determines that its simulated D*
*would never stop running unless aborted*
HHH, everything that HHH calls and DDD
*would never stop running unless* HHH aborts its DDD.
On 5/17/25 5:00 PM, olcott wrote:
On 5/17/2025 3:31 PM, Richard Damon wrote:
On 5/17/25 4:16 PM, olcott wrote:That <is> its correct criterion measure and Mike uses this same
On 5/17/2025 3:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:*H correctly determines that its simulated D*
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:That's correct.
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:If that was actually true then you could provide an >>>>>>>>>>>>>> alternative meaning for the exact words stated above. >>>>>>>>>>>>>>
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means: >>>>>>>>>>>>>>>
*NOT IN THE ACTUAL SPEC*
And since the DD that HHH is simulating WILL HALT when >>>>>>>>>>>>>>>>> fully simulated (an action that HHH doesn't do) >>>>>>>>>>>>>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>>>>> 10/13/2022>
    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 >>>>>>>>>>>>>>>>
I keep challenging you to provide this alternative meaning >>>>>>>>>>>>>> and you dodge because you know that you are lying about >>>>>>>>>>>>>> there being any alternative meaning FOR THE EXACT WORDS >>>>>>>>>>>>>> LISTED ABOVE.
No alternative meaning is needed, just a correct
interpretation of the words (which appear to be incomplete). >>>>>>>>>>>>>
The quoted sentence is cut off, something that I suspect you >>>>>>>>>>>>> didn't notice. Here's the full quotation from a previous >>>>>>>>>>>>> article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>>>>> verbatim paragraph is correct (he has not agreed to >>>>>>>>>>>>>>> anything else in this paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you >>>>>>>>>>>>> claim, **then** H can correctly report the halting status of >>>>>>>>>>>>> D. (That's a paraphrase that probably doesn't capture the >>>>>>>>>>>>> full meaning;
the full **quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>>>>> the manner you claim, then H could correctly report the >>>>>>>>>>>>> halting status of D.
I'm not surprised that Sipser would agree to that. The >>>>>>>>>>>>> problem is that it's a conditional statement whose premise >>>>>>>>>>>>> is impossible.
If an equilateral triangle had four sides, then each of its >>>>>>>>>>>>> four vertices would be 90 degrees. That doesn't actually >>>>>>>>>>>>> mean that there exists an equilateral triangle with four >>>>>>>>>>>>> 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a >>>>>>>>>>>>> general halt decider existed, then there are a lot of things >>>>>>>>>>>>> we could say about it -- but no general halt decider can >>>>>>>>>>>>> exist.
I'm not quite 100% confident in my reasoning here. I invite >>>>>>>>>>>>> any actual experts in computational theory (not you, PO) to >>>>>>>>>>>>> criticize what I've written.
I doubt that Sipser would be using your interpretation, >>>>>>>>>>>> relying on a false premise as a clever kind of logical loop- >>>>>>>>>>>> hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know >>>>>>>>>>> whether a premise is false. It is possible that some
simulating partial decider correctly simulates a part of the >>>>>>>>>>> behaviour of some D and correctly determines that the
unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal >>>>>>>>>>> loop. That one premise is false about HHH with DDD is a part >>>>>>>>>>> of what was asked.
Mike explains all of the details of exactly how a correct
Simulating Halt Decider is derived from the exact meaning of >>>>>>>>>> the words that professor Sipser agreed to IN THE PART THAT YOU >>>>>>>>>> IGNORED
No, he does not. He does not even believe that it is possible to >>>>>>>>> derive a correct Simulating Halt Decider form the exact meaning >>>>>>>>> of any words.
We could build a correct /partial/ SHD though, which I explained. >>>>>>>> The idea behind an PSHD is ok, and a class of HP inputs could be >>>>>>>> correctly decided with a PSHD. Obviously a PSHD H could not
decide its corresponding H^ input, as the Linz HP proof implies. >>>>>>>> Since PO's HHH / does/ decide its corresponding DD (incorrectly), >>>>>>>> it is not a PSHD, since PSHDs are not allowed to decide
incorrectly. Â [A correctly coded PSHD HHH would never halt when >>>>>>>> given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of
Sipser's words. Sipser's words concern how a PSHD H could decide >>>>>>>> some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better than the
next best reviewer. Mike is one of the few people here that really >>>>>>> wants an honest dialogue. He carefully examined my code and has a >>>>>>> nearly perfect understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal at the
expense of truth. Keith and Ben also seem to care about truth.
No, rebuttal for the SAKE of truth.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
*would never stop running unless aborted*
No it doesn't, not unless H never aborts its input.
If H does abort its input, and returns 0, then its simulated input
(which means it fully correctly simulated input) will see DDD call the
actual HHH that will abort and return 0 and thus halt.
HHH, everything that HHH calls and DDD *would never stop runningbut only if HHH never aborts its input.
unless* HHH aborts its DDD.
criterion measure on his infinite loop example.
But it only does a correct simulation if it doesn't abort its
simulation.
PERIOD.
On 5/17/2025 3:31 PM, Richard Damon wrote:
On 5/17/25 4:16 PM, olcott wrote:
On 5/17/2025 3:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means: >>>>>>>>>>>>>>
And since the DD that HHH is simulating WILL HALT when >>>>>>>>>>>>>>>> fully
simulated (an action that HHH doesn't do)
*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>>>> 10/13/2022>
    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 >>>>>>>>>>>>>>>
If that was actually true then you could provide an
alternative meaning for the exact words stated above. >>>>>>>>>>>>>
I keep challenging you to provide this alternative
meaning and you dodge because you know that you are
lying about there being any alternative meaning
FOR THE EXACT WORDS LISTED ABOVE.
No alternative meaning is needed, just a correct
interpretation of the
words (which appear to be incomplete).
The quoted sentence is cut off, something that I suspect you >>>>>>>>>>>> didn't
notice. Here's the full quotation from a previous article: >>>>>>>>>>>>
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>>>> verbatim
paragraph is correct (he has not agreed to anything else >>>>>>>>>>>>>> in this
paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you claim, >>>>>>>>>>>> **then** H can correctly report the halting status of D. >>>>>>>>>>>> (That's a
paraphrase that probably doesn't capture the full meaning; >>>>>>>>>>>> the full
**quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>>>> the manner you claim, then H could correctly report the halting >>>>>>>>>>>> status of D.
I'm not surprised that Sipser would agree to that. The >>>>>>>>>>>> problem is
that it's a conditional statement whose premise is impossible. >>>>>>>>>>>>
If an equilateral triangle had four sides, then each of its >>>>>>>>>>>> four
vertices would be 90 degrees. That doesn't actually mean that >>>>>>>>>>>> there exists an equilateral triangle with four 90-degree >>>>>>>>>>>> vertices,
and in fact no such triangle exists. Similarly, *if* a general >>>>>>>>>>>> halt decider existed, then there are a lot of things we >>>>>>>>>>>> could say
about it -- but no general halt decider can exist.
I'm not quite 100% confident in my reasoning here. I invite >>>>>>>>>>>> any
actual experts in computational theory (not you, PO) to >>>>>>>>>>>> criticize
what I've written.
I doubt that Sipser would be using your interpretation,
relying on a false premise as a clever kind of logical loop- >>>>>>>>>>> hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know >>>>>>>>>> whether a
premise is false. It is possible that some simulating partial >>>>>>>>>> decider
correctly simulates a part of the behaviour of some D and
correctly
determines that the unsimulated part of the behaviour never >>>>>>>>>> halts;
for example, if the unsimulated part is a trivial eternal
loop. That
one premise is false about HHH with DDD is a part of what was >>>>>>>>>> asked.
Mike explains all of the details of exactly how a
correct Simulating Halt Decider is derived from
the exact meaning of the words that professor Sipser
agreed to IN THE PART THAT YOU IGNORED
No, he does not. He does not even believe that it is possible to >>>>>>>> derive
a correct Simulating Halt Decider form the exact meaning of any >>>>>>>> words.
That's correct.
We could build a correct /partial/ SHD though, which I explained. >>>>>>> The idea behind an PSHD is ok, and a class of HP inputs could be >>>>>>> correctly decided with a PSHD. Obviously a PSHD H could not
decide its corresponding H^ input, as the Linz HP proof implies. >>>>>>> Since PO's HHH / does/ decide its corresponding DD (incorrectly), >>>>>>> it is not a PSHD, since PSHDs are not allowed to decide
incorrectly. Â [A correctly coded PSHD HHH would never halt when >>>>>>> given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of
Sipser's words. Sipser's words concern how a PSHD H could decide >>>>>>> some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better
than the next best reviewer. Mike is one of the few
people here that really wants an honest dialogue. He
carefully examined my code and has a nearly perfect
understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal
at the expense of truth. Keith and Ben also seem to
care about truth.
No, rebuttal for the SAKE of truth.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> Â Â Â Â 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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
*H correctly determines that its simulated D*
*would never stop running unless aborted*
No it doesn't, not unless H never aborts its input.
If H does abort its input, and returns 0, then its simulated input
(which means it fully correctly simulated input) will see DDD call the
actual HHH that will abort and return 0 and thus halt.
HHH, everything that HHH calls and DDD
*would never stop running unless* HHH aborts its DDD.
but only if HHH never aborts its input.
That <is> its correct criterion measure and Mike
uses this same criterion measure on his infinite
loop example.
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/? STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
  H correctly simulates as far as [A], at which point
  it correctly determines that
  "its simulated input would never stop running unless aborted",
  so it can decide "non-halting".
H is not reporting on actual the behavior of H(D)
that halts after D has been aborted.
H is reporting on what the behavior of D would be
if it never aborted D.
Has this always been merely confusion on your part?
ADD may make it very difficult to stat focused on
a single point.
On the other hand an OCD like focus on a single point
notices every attempt to divert attention away from
this point.
No one else even notices that attempting to divert
attention away from the point at hand is not a
valid rebuttal.
On 5/17/2025 8:08 AM, Richard Damon wrote:
On 5/16/25 11:08 PM, olcott wrote:
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides >>>>>>>>>>> a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition 'correctly
simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this exact >>>>>>>> input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program and >>>>>> thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
Read all the message.
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the code
of the HHH it was built for, which is the HHH that aborts and returns 0. >>>>
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
No, its job is to determine if the program that the input represents will halt.
*THAT IS NOT WHAT THE ABOVE SPEC SAYS KNUCKLEHEAD*
On 5/17/2025 4:03 AM, Fred. Zwarts wrote:
Op 17.mei.2025 om 05:08 schreef olcott:
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    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. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides >>>>>>>>>>> a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition 'correctly
simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this exact >>>>>>>> input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program and >>>>>> thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the code
of the HHH it was built for, which is the HHH that aborts and returns 0. >>>>
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
No, it is the task of HHH to determine whether *this* input, that
includes Halt7.c and which does specify a conditional abort, halts.
I am only asking DOES HHH meet the above spec?
You keep changing the subject away from this.
On 5/17/2025 6:35 PM, Richard Damon wrote:
On 5/17/25 5:00 PM, olcott wrote:
That <is> its correct criterion measure and Mike
uses this same criterion measure on his infinite
loop example.
But it only does a correct simulation if it doesn't abort its simulation.
PERIOD.
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
   H correctly simulates as far as [A], at which point
   it correctly determines that
   "its simulated input would never stop running unless aborted",
   so it can decide "non-halting".
H is not reporting on actual the behavior of H(D)
that halts after D has been aborted.
It isn't? Then it isn't a Halt Decider.
Mike said it is a correct partial halt decider
when his SHD simulates an infinite loop and then
reports on the behavior of what would happen
if this SHD did not abort its simulation.
Thus Mike says that the SHD should not report
on the actual behavior of SHD/infinite loop
that does abort its input.
On 5/17/2025 4:03 AM, Fred. Zwarts wrote:
Op 17.mei.2025 om 05:08 schreef olcott:
On 5/16/2025 9:50 PM, Richard Damon wrote:
On 5/16/25 8:49 PM, olcott wrote:
On 5/16/2025 7:38 PM, Richard Damon wrote:
On 5/16/25 6:39 PM, olcott wrote:
On 5/16/2025 5:03 PM, Richard Damon wrote:
On 5/16/25 4:29 PM, olcott wrote:
On 5/16/2025 3:06 PM, Fred. Zwarts wrote:
Op 16.mei.2025 om 07:29 schreef olcott:
*Not at all. I am following these exact words*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
    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. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
On 5/14/2025 7:36 PM, Mike Terry wrote:
Shows exactly how to implement those words to implement
a correct Simulating Termination Analyzer. Mike provides >>>>>>>>>>> a complete example of how this works.
Sipser agreed to a vacuous statement, because the condition >>>>>>>>>> 'correctly simulates' was not met.
And by this you mean that when the spec requires
a partial simulation
*until H correctly determines that its simulated D*
*would never stop running unless aborted*
You "interpret" this to mean that it must
infinitely simulate non-terminating inputs.
Which means, as I explained else, if H, after doing a partial
simulation, can determine that a COMPLETE simulation of this
exact input would be non-halting, it can abort.
Not quite. One key detail is missing.
*H correctly determines that its simulated D*
*would never stop running unless aborted*
Is referring to what the behavior of D would be
(in the hypothetical case) where this very same
H never aborted.
Nope, since D must stay D, and D must be a fully encoded program
and thus doesn't change when you make the hypothetical H.
*Click here to get the whole article*
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
Mike perfectly explains all of this with a concrete
example. In this case H determines that its infinite
loop input would never stop running unless aborted
so it aborts it and correctly rejects it.
H is not being asked what is the behavior of this
infinite loop after H aborts it. It is being asked
what its behavior would be if H never aborted it.
HHH is not being asked what is the behavior of
DDD after HHH aborts it. It is being asked
what its behavior would be if HHH never aborted it.
What makes you think I haven't.
You haven't what?
And, since DDD needs to be a PROGRAM to do any of this, as non-leaf
functions can't be correctly emulated, that DDD DOES include the
code of the HHH it was built for, which is the HHH that aborts and
returns 0.
It is the job of HHH to determine whether or not its
input *WOULD NEVER STOP RUNNING UNLESS ABORTED*
No, it is the task of HHH to determine whether *this* input, that
includes Halt7.c and which does specify a conditional abort, halts.
I am only asking DOES HHH meet the above spec?
You keep changing the subject away from this.
On 5/17/2025 6:56 PM, Mr Flibble wrote:
On Sat, 17 May 2025 19:35:12 -0400, Richard Damon wrote:
On 5/17/25 5:00 PM, olcott wrote:
On 5/17/2025 3:31 PM, Richard Damon wrote:
On 5/17/25 4:16 PM, olcott wrote:That <is> its correct criterion measure and Mike uses this same
On 5/17/2025 3:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:*H correctly determines that its simulated D*
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:That's correct.
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:If that was actually true then you could provide an >>>>>>>>>>>>>>>> alternative meaning for the exact words stated above. >>>>>>>>>>>>>>>>
On 5/14/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>That Sipser didn't agree what you think the above means: >>>>>>>>>>>>>>>>>
And since the DD that HHH is simulating WILL HALT when >>>>>>>>>>>>>>>>>>> fully simulated (an action that HHH doesn't do) >>>>>>>>>>>>>>>>>>*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>>>>>>> 10/13/2022>
     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 >>>>>>>>>>>>>>>>>>
I keep challenging you to provide this alternative meaning >>>>>>>>>>>>>>>> and you dodge because you know that you are lying about >>>>>>>>>>>>>>>> there being any alternative meaning FOR THE EXACT WORDS >>>>>>>>>>>>>>>> LISTED ABOVE.
No alternative meaning is needed, just a correct >>>>>>>>>>>>>>> interpretation of the words (which appear to be incomplete). >>>>>>>>>>>>>>>
The quoted sentence is cut off, something that I suspect you >>>>>>>>>>>>>>> didn't notice. Here's the full quotation from a previous >>>>>>>>>>>>>>> article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>>>>>>> verbatim paragraph is correct (he has not agreed to >>>>>>>>>>>>>>>>> anything else in this paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you >>>>>>>>>>>>>>> claim, **then** H can correctly report the halting status of >>>>>>>>>>>>>>> D. (That's a paraphrase that probably doesn't capture the >>>>>>>>>>>>>>> full meaning;
the full **quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>>>>>>> the manner you claim, then H could correctly report the >>>>>>>>>>>>>>> halting status of D.
I'm not surprised that Sipser would agree to that. The >>>>>>>>>>>>>>> problem is that it's a conditional statement whose premise >>>>>>>>>>>>>>> is impossible.
If an equilateral triangle had four sides, then each of its >>>>>>>>>>>>>>> four vertices would be 90 degrees. That doesn't actually >>>>>>>>>>>>>>> mean that there exists an equilateral triangle with four >>>>>>>>>>>>>>> 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a >>>>>>>>>>>>>>> general halt decider existed, then there are a lot of things >>>>>>>>>>>>>>> we could say about it -- but no general halt decider can >>>>>>>>>>>>>>> exist.
I'm not quite 100% confident in my reasoning here. I invite >>>>>>>>>>>>>>> any actual experts in computational theory (not you, PO) to >>>>>>>>>>>>>>> criticize what I've written.
I doubt that Sipser would be using your interpretation, >>>>>>>>>>>>>> relying on a false premise as a clever kind of logical loop- >>>>>>>>>>>>>> hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know >>>>>>>>>>>>> whether a premise is false. It is possible that some >>>>>>>>>>>>> simulating partial decider correctly simulates a part of the >>>>>>>>>>>>> behaviour of some D and correctly determines that the >>>>>>>>>>>>> unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal >>>>>>>>>>>>> loop. That one premise is false about HHH with DDD is a part >>>>>>>>>>>>> of what was asked.
Mike explains all of the details of exactly how a correct >>>>>>>>>>>> Simulating Halt Decider is derived from the exact meaning of >>>>>>>>>>>> the words that professor Sipser agreed to IN THE PART THAT YOU >>>>>>>>>>>> IGNORED
No, he does not. He does not even believe that it is possible to >>>>>>>>>>> derive a correct Simulating Halt Decider form the exact meaning >>>>>>>>>>> of any words.
We could build a correct /partial/ SHD though, which I explained. >>>>>>>>>> The idea behind an PSHD is ok, and a class of HP inputs could be >>>>>>>>>> correctly decided with a PSHD. Obviously a PSHD H could not >>>>>>>>>> decide its corresponding H^ input, as the Linz HP proof implies. >>>>>>>>>> Since PO's HHH / does/ decide its corresponding DD (incorrectly), >>>>>>>>>> it is not a PSHD, since PSHDs are not allowed to decide
incorrectly. Â [A correctly coded PSHD HHH would never halt when >>>>>>>>>> given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of >>>>>>>>>> Sipser's words. Sipser's words concern how a PSHD H could decide >>>>>>>>>> some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better than the >>>>>>>>> next best reviewer. Mike is one of the few people here that really >>>>>>>>> wants an honest dialogue. He carefully examined my code and has a >>>>>>>>> nearly perfect understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.cNo, rebuttal for the SAKE of truth.
Most everyone else only seems to care about rebuttal at the
expense of truth. Keith and Ben also seem to care about truth. >>>>>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
*would never stop running unless aborted*
No it doesn't, not unless H never aborts its input.
If H does abort its input, and returns 0, then its simulated input
(which means it fully correctly simulated input) will see DDD call the >>>>> actual HHH that will abort and return 0 and thus halt.
HHH, everything that HHH calls and DDD *would never stop runningbut only if HHH never aborts its input.
unless* HHH aborts its DDD.
criterion measure on his infinite loop example.
But it only does a correct simulation if it doesn't abort its
simulation.
PERIOD.
No, it only needs to report a correct halting result *as if* the
simulation was run to completion: whether we abort, or continue until we
run out of stack space makes no difference: we are detecting INFINITE
recursion which can be viewed as non-halting.
/Flibble
Thanks for your support. I was shocked how quickly
you picked this stuff up. Much quicker than me.
Like me you don't have a perfect understanding
of every nuance of the terminology.
Unlike most everyone else you have a much deeper
understanding of the key gist of these ideas.
Most everyone else has no actual understanding.
They can only parrot what textbooks say.
On 5/17/2025 6:56 PM, Mr Flibble wrote:
On Sat, 17 May 2025 19:35:12 -0400, Richard Damon wrote:
On 5/17/25 5:00 PM, olcott wrote:
On 5/17/2025 3:31 PM, Richard Damon wrote:
On 5/17/25 4:16 PM, olcott wrote:That <is> its correct criterion measure and Mike uses this same
On 5/17/2025 3:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:*H correctly determines that its simulated D*
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:That's correct.
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:If that was actually true then you could provide an >>>>>>>>>>>>>>>> alternative meaning for the exact words stated above. >>>>>>>>>>>>>>>>
On 5/14/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>That Sipser didn't agree what you think the above means: >>>>>>>>>>>>>>>>>
And since the DD that HHH is simulating WILL HALT when >>>>>>>>>>>>>>>>>>> fully simulated (an action that HHH doesn't do) >>>>>>>>>>>>>>>>>>*NOT IN THE ACTUAL SPEC*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>>>>>>> 10/13/2022>
     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 >>>>>>>>>>>>>>>>>>
I keep challenging you to provide this alternative meaning >>>>>>>>>>>>>>>> and you dodge because you know that you are lying about >>>>>>>>>>>>>>>> there being any alternative meaning FOR THE EXACT WORDS >>>>>>>>>>>>>>>> LISTED ABOVE.
No alternative meaning is needed, just a correct >>>>>>>>>>>>>>> interpretation of the words (which appear to be incomplete). >>>>>>>>>>>>>>>
The quoted sentence is cut off, something that I suspect you >>>>>>>>>>>>>>> didn't notice. Here's the full quotation from a previous >>>>>>>>>>>>>>> article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>>>>>>> verbatim paragraph is correct (he has not agreed to >>>>>>>>>>>>>>>>> anything else in this paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you >>>>>>>>>>>>>>> claim, **then** H can correctly report the halting status of >>>>>>>>>>>>>>> D. (That's a paraphrase that probably doesn't capture the >>>>>>>>>>>>>>> full meaning;
the full **quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>>>>>>> the manner you claim, then H could correctly report the >>>>>>>>>>>>>>> halting status of D.
I'm not surprised that Sipser would agree to that. The >>>>>>>>>>>>>>> problem is that it's a conditional statement whose premise >>>>>>>>>>>>>>> is impossible.
If an equilateral triangle had four sides, then each of its >>>>>>>>>>>>>>> four vertices would be 90 degrees. That doesn't actually >>>>>>>>>>>>>>> mean that there exists an equilateral triangle with four >>>>>>>>>>>>>>> 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a >>>>>>>>>>>>>>> general halt decider existed, then there are a lot of things >>>>>>>>>>>>>>> we could say about it -- but no general halt decider can >>>>>>>>>>>>>>> exist.
I'm not quite 100% confident in my reasoning here. I invite >>>>>>>>>>>>>>> any actual experts in computational theory (not you, PO) to >>>>>>>>>>>>>>> criticize what I've written.
I doubt that Sipser would be using your interpretation, >>>>>>>>>>>>>> relying on a false premise as a clever kind of logical loop- >>>>>>>>>>>>>> hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know >>>>>>>>>>>>> whether a premise is false. It is possible that some >>>>>>>>>>>>> simulating partial decider correctly simulates a part of the >>>>>>>>>>>>> behaviour of some D and correctly determines that the >>>>>>>>>>>>> unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal >>>>>>>>>>>>> loop. That one premise is false about HHH with DDD is a part >>>>>>>>>>>>> of what was asked.
Mike explains all of the details of exactly how a correct >>>>>>>>>>>> Simulating Halt Decider is derived from the exact meaning of >>>>>>>>>>>> the words that professor Sipser agreed to IN THE PART THAT YOU >>>>>>>>>>>> IGNORED
No, he does not. He does not even believe that it is possible to >>>>>>>>>>> derive a correct Simulating Halt Decider form the exact meaning >>>>>>>>>>> of any words.
We could build a correct /partial/ SHD though, which I explained. >>>>>>>>>> The idea behind an PSHD is ok, and a class of HP inputs could be >>>>>>>>>> correctly decided with a PSHD. Obviously a PSHD H could not >>>>>>>>>> decide its corresponding H^ input, as the Linz HP proof implies. >>>>>>>>>> Since PO's HHH / does/ decide its corresponding DD (incorrectly), >>>>>>>>>> it is not a PSHD, since PSHDs are not allowed to decide
incorrectly. Â [A correctly coded PSHD HHH would never halt when >>>>>>>>>> given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of >>>>>>>>>> Sipser's words. Sipser's words concern how a PSHD H could decide >>>>>>>>>> some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better than the >>>>>>>>> next best reviewer. Mike is one of the few people here that really >>>>>>>>> wants an honest dialogue. He carefully examined my code and has a >>>>>>>>> nearly perfect understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.cNo, rebuttal for the SAKE of truth.
Most everyone else only seems to care about rebuttal at the
expense of truth. Keith and Ben also seem to care about truth. >>>>>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
*would never stop running unless aborted*
No it doesn't, not unless H never aborts its input.
If H does abort its input, and returns 0, then its simulated input
(which means it fully correctly simulated input) will see DDD call the >>>>> actual HHH that will abort and return 0 and thus halt.
HHH, everything that HHH calls and DDD *would never stop runningbut only if HHH never aborts its input.
unless* HHH aborts its DDD.
criterion measure on his infinite loop example.
But it only does a correct simulation if it doesn't abort its
simulation.
PERIOD.
No, it only needs to report a correct halting result *as if* the
simulation was run to completion: whether we abort, or continue until we
run out of stack space makes no difference: we are detecting INFINITE
recursion which can be viewed as non-halting.
/Flibble
Thanks for your support. I was shocked how quickly
you picked this stuff up. Much quicker than me.
Like me you don't have a perfect understanding
of every nuance of the terminology.
Unlike most everyone else you have a much deeper
understanding of the key gist of these ideas.
Most everyone else has no actual understanding.
They can only parrot what textbooks say.
On 5/17/2025 6:35 PM, Richard Damon wrote:
On 5/17/25 5:00 PM, olcott wrote:
That <is> its correct criterion measure and Mike
uses this same criterion measure on his infinite
loop example.
But it only does a correct simulation if it doesn't abort its simulation.
PERIOD.
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/?
STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E
   H correctly simulates as far as [A], at which point
   it correctly determines that
   "its simulated input would never stop running unless aborted",
   so it can decide "non-halting".
H is not reporting on actual the behavior of H(D)
that halts after D has been aborted.
It isn't? Then it isn't a Halt Decider.
Mike said it is a correct partial halt decider
when his SHD simulates an infinite loop and then
reports on the behavior of what would happen
if this SHD did not abort its simulation.
Thus Mike says that the SHD should not report
on the actual behavior of SHD/infinite loop
that does abort its input.
If you can't pay attention to these details about
what Mike said because of your ADD how is your
performance at work? Does anyone at work notice
that you can't keep focus on a single point?
On Sat, 17 May 2025 19:35:12 -0400, Richard Damon wrote:
On 5/17/25 5:00 PM, olcott wrote:
On 5/17/2025 3:31 PM, Richard Damon wrote:
On 5/17/25 4:16 PM, olcott wrote:That <is> its correct criterion measure and Mike uses this same
On 5/17/2025 3:05 PM, olcott wrote:
On 5/17/2025 2:54 PM, Richard Damon wrote:*H correctly determines that its simulated D*
On 5/17/25 11:31 AM, olcott wrote:
On 5/17/2025 9:27 AM, Mike Terry wrote:
On 17/05/2025 09:55, Mikko wrote:
On 2025-05-16 14:47:39 +0000, olcott said:That's correct.
On 5/16/2025 4:26 AM, Mikko wrote:
On 2025-05-15 00:36:21 +0000, Mike Terry said:
On 14/05/2025 22:31, Keith Thompson wrote:
olcott <polcott333@gmail.com> writes:
On 5/14/2025 3:51 PM, dbush wrote:
On 5/14/2025 11:45 AM, olcott wrote:If that was actually true then you could provide an >>>>>>>>>>>>>>> alternative meaning for the exact words stated above. >>>>>>>>>>>>>>>
On 5/14/2025 6:20 AM, Richard Damon wrote:That Sipser didn't agree what you think the above means: >>>>>>>>>>>>>>>>
*NOT IN THE ACTUAL SPEC*
And since the DD that HHH is simulating WILL HALT when >>>>>>>>>>>>>>>>>> fully simulated (an action that HHH doesn't do) >>>>>>>>>>>>>>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>>>>>> 10/13/2022>
    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 >>>>>>>>>>>>>>>>>
I keep challenging you to provide this alternative meaning >>>>>>>>>>>>>>> and you dodge because you know that you are lying about >>>>>>>>>>>>>>> there being any alternative meaning FOR THE EXACT WORDS >>>>>>>>>>>>>>> LISTED ABOVE.
No alternative meaning is needed, just a correct
interpretation of the words (which appear to be incomplete). >>>>>>>>>>>>>>
The quoted sentence is cut off, something that I suspect you >>>>>>>>>>>>>> didn't notice. Here's the full quotation from a previous >>>>>>>>>>>>>> article:
<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following >>>>>>>>>>>>>>>> verbatim paragraph is correct (he has not agreed to >>>>>>>>>>>>>>>> anything else in this paper):
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.
</Sipser approved abstract>
**If** H correctly simulates its input in the manner you >>>>>>>>>>>>>> claim, **then** H can correctly report the halting status of >>>>>>>>>>>>>> D. (That's a paraphrase that probably doesn't capture the >>>>>>>>>>>>>> full meaning;
the full **quotation is above.)
To put it another way, If H correctly simulated its input in >>>>>>>>>>>>>> the manner you claim, then H could correctly report the >>>>>>>>>>>>>> halting status of D.
I'm not surprised that Sipser would agree to that. The >>>>>>>>>>>>>> problem is that it's a conditional statement whose premise >>>>>>>>>>>>>> is impossible.
If an equilateral triangle had four sides, then each of its >>>>>>>>>>>>>> four vertices would be 90 degrees. That doesn't actually >>>>>>>>>>>>>> mean that there exists an equilateral triangle with four >>>>>>>>>>>>>> 90-degree vertices,
and in fact no such triangle exists. Similarly, *if* a >>>>>>>>>>>>>> general halt decider existed, then there are a lot of things >>>>>>>>>>>>>> we could say about it -- but no general halt decider can >>>>>>>>>>>>>> exist.
I'm not quite 100% confident in my reasoning here. I invite >>>>>>>>>>>>>> any actual experts in computational theory (not you, PO) to >>>>>>>>>>>>>> criticize what I've written.
I doubt that Sipser would be using your interpretation, >>>>>>>>>>>>> relying on a false premise as a clever kind of logical loop- >>>>>>>>>>>>> hole to basically fob someone off.
The details of H are not known to Sipser, so he can't know >>>>>>>>>>>> whether a premise is false. It is possible that some
simulating partial decider correctly simulates a part of the >>>>>>>>>>>> behaviour of some D and correctly determines that the
unsimulated part of the behaviour never halts;
for example, if the unsimulated part is a trivial eternal >>>>>>>>>>>> loop. That one premise is false about HHH with DDD is a part >>>>>>>>>>>> of what was asked.
Mike explains all of the details of exactly how a correct >>>>>>>>>>> Simulating Halt Decider is derived from the exact meaning of >>>>>>>>>>> the words that professor Sipser agreed to IN THE PART THAT YOU >>>>>>>>>>> IGNORED
No, he does not. He does not even believe that it is possible to >>>>>>>>>> derive a correct Simulating Halt Decider form the exact meaning >>>>>>>>>> of any words.
We could build a correct /partial/ SHD though, which I explained. >>>>>>>>> The idea behind an PSHD is ok, and a class of HP inputs could be >>>>>>>>> correctly decided with a PSHD. Obviously a PSHD H could not >>>>>>>>> decide its corresponding H^ input, as the Linz HP proof implies. >>>>>>>>> Since PO's HHH / does/ decide its corresponding DD (incorrectly), >>>>>>>>> it is not a PSHD, since PSHDs are not allowed to decide
incorrectly. Â [A correctly coded PSHD HHH would never halt when >>>>>>>>> given its (HHH^,HHH^) input.
PO's problem is that he misunderstands the entire context of >>>>>>>>> Sipser's words. Sipser's words concern how a PSHD H could decide >>>>>>>>> some FIXED INPUT D it has been given.
Mike's reviews of my work are at least ten-fold better than the >>>>>>>> next best reviewer. Mike is one of the few people here that really >>>>>>>> wants an honest dialogue. He carefully examined my code and has a >>>>>>>> nearly perfect understanding.
And he still points out how you are wrong.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Most everyone else only seems to care about rebuttal at the
expense of truth. Keith and Ben also seem to care about truth.
No, rebuttal for the SAKE of truth.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
    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
Right, ans since your HHH and DDD are not programs
I will not tolerate changing the subject you damned liar!
*would never stop running unless aborted*
No it doesn't, not unless H never aborts its input.
If H does abort its input, and returns 0, then its simulated input
(which means it fully correctly simulated input) will see DDD call the >>>> actual HHH that will abort and return 0 and thus halt.
HHH, everything that HHH calls and DDD *would never stop runningbut only if HHH never aborts its input.
unless* HHH aborts its DDD.
criterion measure on his infinite loop example.
But it only does a correct simulation if it doesn't abort its
simulation.
PERIOD.
No, it only needs to report a correct halting result *as if* the
simulation was run to completion: whether we abort, or continue until we
run out of stack space makes no difference: we are detecting INFINITE recursion which can be viewed as non-halting.
/Flibble
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 12:25:26 |
| Calls: | 10,387 |
| Calls today: | 2 |
| Files: | 14,061 |
| Messages: | 6,416,717 |