Suppose there is a decider H that takes a finite
string of source code S. H applies inference steps
to S according to the operational semantics of the
language of S.
What exactly would that entail?
On 11/6/2026 8:08 PM, olcott wrote:
Suppose there is a decider H that takes a finite
string of source code S. H applies inference steps
to S according to the operational semantics of the
language of S.
What exactly would that entail?
What I mean by halt decider is more technically called
a partial halt decider that correctly determines the
halt status of some inputs.
Software engineering calls this exact same thing a
termination analyzer. Here is an example of one of these.
AProVE: Non-Termination Witnesses for C Programsria https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21
How can a generic halt decider examine the behavior
that a static finite string of source-code specifies?
Suppose there is a decider H that takes a finite
string of source code S. H applies inference steps
to S according to the operational semantics of the
language of S.
What exactly would that entail?
Le 07/11/2026 |a 16:25, olcott a |-crit :
On 11/6/2026 8:08 PM, olcott wrote:
Suppose there is a decider H that takes a finite
string of source code S. H applies inference steps
to S according to the operational semantics of the
language of S.
What exactly would that entail?
What I mean by halt decider is more technically called
a partial halt decider that correctly determines the
halt status of some inputs.
Software engineering calls this exact same thing a
termination analyzer. Here is an example of one of these.
AProVE: Non-Termination Witnesses for C Programsria
https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21
How can a generic halt decider examine the behavior
that a static finite string of source-code specifies?
Peter,
WELL, FUCKING FINALLY.
After twenty-two years of claiming to have refuted the Halting Theorem,
you now write:
-a-a "What I mean by halt decider is more technically
-a-a-a called a partial halt decider that correctly
-a-a-a determines the halt status of some inputs."
GOOD.
Then you have NOT refuted the Halting Theorem.
Partial termination analyzers are perfectly legitimate. Nobody has ever disputed their existence.
The Halting Theorem does not prohibit proving termination or non- termination for SOME programs.
And the AProVE paper you cite is particularly instructive.
AProVE uses symbolic execution and mathematical analysis to establish termination or non-termination. When it proves non-termination, it can produce a witness identifying a non-terminating execution path in the original program.
THAT is what a justified non-termination result looks like.
Now compare that with HHH.
Your detector observes a finite pattern of calls and concludes that execution cannot terminate.
WHERE IS YOUR PROOF THAT THIS PATTERN GUARANTEES NON-TERMINATION?
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
WHERE IS YOUR CORRESPONDING NON-TERMINATION WITNESS?
And please don't tell us that the input is a finite string. We already
know that.
As for your question:
-a-a "How can a generic halt decider examine the behavior
-a-a-a that a static finite string of source-code specifies?"
By interpreting or analyzing the program according to its semantics.
Through concrete execution, symbolic execution, abstract interpretation, invariants, ranking functions, transition systems, or other sound methods.
NONE of these requires enumerating the entire execution trace.
But every claimed result must be justified.
And here is the decisive distinction:
-a-a A partial analyzer may legitimately answer UNKNOWN.
-a-a It may legitimately fail to terminate on some inputs.
-a-a It may NOT legitimately answer DOES NOT HALT
-a-a when the program actually halts.
Calling such an input "outside the domain" AFTER your analyzer has
returned the wrong answer does not make the answer correct.
So let's establish your new position clearly.
If HHH is merely a partial termination analyzer, then its existence is entirely compatible with the Halting Theorem.
If you claim HHH correctly recognizes some non-terminating programs,
prove its soundness on that class.
If you claim it refutes the Halting Theorem, you need something MUCH stronger.
You cannot have it both ways.
And you certainly cannot use the existence of legitimate tools like
AProVE as evidence that your own detector is correct.
WELCOME TO THE ACTUAL SUBJECT OF TERMINATION ANALYSIS.
Now prove that HHH belongs among the sound analyzers.
Peter,
HERE WE FUCKING GO AGAIN.
You write:
-a-a "I am not going to go around and around proving
-a-a-a that same points that have been accepted as true."
NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.
We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.
And once again, you quote me:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.
I have explicitly rejected that inference, repeatedly, publicly, and in unmistakable language.
You KNOW that.
You even admitted:
-a-a "We have only established that HHH would be
-a-a-a correct IF HHH did determine that."
Exactly.
You have not established that HHH DOES correctly determine it.
And now you write:
-a-a "The end-result must be behavior equivalent
-a-a-a to DD simulated by HHH
-a-a-a try to prove otherwise or accept this."
NO.
YOU are asserting that requirement.
YOU must justify it.
A sound termination analyzer must correctly establish the termination behavior specified by the program's semantics.
On 11/7/2026 10:36 AM, Python wrote:
Peter,
HERE WE FUCKING GO AGAIN.
You write:
-a-a "I am not going to go around and around proving
-a-a-a that same points that have been accepted as true."
NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.
We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.
And once again, you quote me:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.
I have explicitly rejected that inference, repeatedly, publicly, and in
unmistakable language.
You KNOW that.
You even admitted:
-a-a "We have only established that HHH would be
-a-a-a correct IF HHH did determine that."
Exactly.
You have not established that HHH DOES correctly determine it.
And now you write:
-a-a "The end-result must be behavior equivalent
-a-a-a to DD simulated by HHH
-a-a-a try to prove otherwise or accept this."
NO.
YOU are asserting that requirement.
YOU must justify it.
A sound termination analyzer must correctly establish the termination
behavior specified by the program's semantics.
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
The above is self-evidently true.
I will not play head games with you on this.
If you do not accept that HHH does correctly
determine the above then I am done talking to you.
It took me five years to get agreement on the
above paragraph because everyone on this forum
thought that lying about a self-evident truth
was funny.
Le 07/11/2026 |a 17:56, olcott a |-crit :
On 11/7/2026 10:36 AM, Python wrote:
Peter,
HERE WE FUCKING GO AGAIN.
You write:
-a-a-a "I am not going to go around and around proving
-a-a-a-a that same points that have been accepted as true."
NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.
We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.
And once again, you quote me:
-a-a-a WHILE THE SIMULATION CONTINUES,
-a-a-a DD DOES NOT REACH ITS RETURN.
STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.
I have explicitly rejected that inference, repeatedly, publicly, and
in unmistakable language.
You KNOW that.
You even admitted:
-a-a-a "We have only established that HHH would be
-a-a-a-a correct IF HHH did determine that."
Exactly.
You have not established that HHH DOES correctly determine it.
And now you write:
-a-a-a "The end-result must be behavior equivalent
-a-a-a-a to DD simulated by HHH
-a-a-a-a try to prove otherwise or accept this."
NO.
YOU are asserting that requirement.
YOU must justify it.
A sound termination analyzer must correctly establish the termination
behavior specified by the program's semantics.
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
The above is self-evidently true.
I will not play head games with you on this.
If you do not accept that HHH does correctly
determine the above then I am done talking to you.
It took me five years to get agreement on the
above paragraph because everyone on this forum
thought that lying about a self-evident truth
was funny.
Peter,
You write:
-a-a "There does not exist any implementation of C
-a-a-a function HHH that simulates C function DD
-a-a-a according to the operational semantics of C
-a-a-a such that the simulated C function DD reaches
-a-a-a its own simulated return statement in any N
-a-a-a finite number of steps."
And then:
-a-a "The above is self-evidently true."
NO, PETER.
You have just made a universally quantified mathematical claim.
You do not get to declare it "self-evident" and then accuse anyone who
asks for a proof of lying.
More importantly, you are AGAIN conflating two different propositions.--
I agreed that:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
That does not establish that your HHH correctly determines the halting behavior of DD.
And your new statement does not establish it either.
Let's consider the actual diagonal argument.
Suppose HHH is a TOTAL and CORRECT halt decider.
Then DD behaves as follows:
-a-a If HHH(DD) says HALTS, DD loops.
-a-a If HHH(DD) says DOES NOT HALT, DD returns.
Therefore HHH cannot give a correct halting answer for DD.
If HHH fails to return, it is not total.
THAT IS THE CONTRADICTION.
It establishes the impossibility of a total correct halt decider.
It does NOT establish the correctness of your implementation.
Now consider your actual simulator.
There is an OUTER invocation of HHH.
It simulates DD, which invokes a NESTED HHH.
That nested invocation is part of the simulated computation.
If the outer HHH aborts its simulation and returns DOES NOT HALT, this
does NOT mean that the nested HHH returned DOES NOT HALT to DD.
Those are DIFFERENT invocations.
The simulated DD may simply have been abandoned before reaching any
return statement.
And THAT is exactly why your conclusion does not follow.
You have to establish that the behavior observed by the outer HHH
justifies its verdict about DD.
You cannot establish that by pointing out that DD did not return BEFORE
YOU ABORTED ITS SIMULATION.
And you cannot establish it by repeatedly quoting my agreement to a different proposition.
You say:
-a-a "If you do not accept that HHH does correctly
-a-a-a determine the above then I am done talking
-a-a-a to you."
That is not an argument.
That is an ultimatum.
You have spent years claiming to have refuted a mathematical theorem.
The burden of proof is yours.
If you want to stop talking rather than demonstrate the correctness of
your inference, that is your choice.
But stop pretending that my agreement to a limited statement constitutes acceptance of your purported proof.
IT DOES NOT.
Peter,
-a-a "Good bye."
Fine.
For the record, you have NOT demonstrated that your HHH correctly
determines the halting status of DD.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
You have repeatedly quoted a proposition I agreed to, while refusing to justify the additional conclusion you draw from it.--
Those are TWO DIFFERENT THINGS.
You have also failed to explain why aborting an outer simulation
establishes the non-termination of the simulated program, rather than
merely terminating the simulation itself.
Declaring your conclusion "self-evident" is not a proof.
Accusing people who request a proof of lying is not a proof.
And walking away when asked to justify your inference is certainly not a proof.
If you ever decide to provide an actual mathematical argument, rather
than another quotation of my words, I will be happy to examine it.
Until then, your claimed refutation of the Halting Theorem remains unsubstantiated.
Goodbye.
Peter,
YOU SAID GOODBYE.
And yet here you are again, repeating the SAME FUCKING QUOTATION.
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a DD DOES NOT REACH ITS RETURN."
YES, PETER. I SAID THAT.
AND I STAND BY THOSE EXACT WORDS.
What I do NOT accept is your claim that this establishes the correctness
of HHH's non-halting verdict.
HOW MANY FUCKING TIMES DO I HAVE TO EXPLAIN THE DIFFERENCE?--
You write:
-a-a "*is shown to be equivalent to this*"
SHOWN WHERE?
BY WHAT ARGUMENT?
BY WHICH INFERENCE RULE?
You have not demonstrated an equivalence. You have merely ANNOUNCED one.
And now you call it "self-evident".
A statement about what happens WHILE a simulation continues is not, by itself, a proof that a program can NEVER terminate.
In particular, your outer HHH can abort its simulation without the
nested HHH ever returning a result to the simulated DD.
THOSE ARE DIFFERENT EVENTS.
That distinction has been explained to you repeatedly.
You have NEVER addressed it.
Instead, you recycle my quotation, accuse your critics of lying, and
declare victory.
Let me make something ABSOLUTELY CLEAR:
**MY AGREEMENT TO ONE PROPOSITION IS NOT MY AGREEMENT TO YOUR
CONCLUSIONS.**
You do not get to manufacture my endorsement by repeatedly quoting half
the argument.
And this:
-a-a "people on this forum denied for five years
-a-a-a because they thought denying a self-evident
-a-a-a truth is funny"
is another baseless accusation.
People have challenged your reasoning because you have FAILED TO JUSTIFY
IT.
Not because they enjoy lying.
Not because they are playing games.
Not because they are incapable of understanding your supposedly profound insights.
BECAUSE YOU HAVE NOT PROVIDED THE FUCKING PROOF.
Twenty-two years of repetition do not turn an unsupported inference into
a theorem.
Five years of arguments do not make your conclusion self-evident.
And quoting me for the hundredth time does not establish anything beyond
the words I actually wrote.
You claim that HHH correctly determines non-termination.
PROVE IT.
You claim that your two propositions are equivalent.
PROVE IT.
You claim to have refuted the Halting Theorem.
PROVE IT.
Or admit that all you have is an assertion you cannot justify.
And one last thing:
STOP ACCUSING PEOPLE OF LYING SIMPLY BECAUSE THEY REFUSE TO ACCEPT YOUR UNPROVEN CLAIMS.
That is not mathematics.
That is intellectual dishonesty.
On 11/7/2026 11:47 AM, Python wrote:
Peter,
YOU SAID GOODBYE.
And yet here you are again, repeating the SAME FUCKING QUOTATION.
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a DD DOES NOT REACH ITS RETURN."
YES, PETER. I SAID THAT.
AND I STAND BY THOSE EXACT WORDS.
What I do NOT accept is your claim that this establishes the correctness
of HHH's non-halting verdict.
That part is OK to disagree with.
The part that is not OK to disagree with is
that HHH does not correctly determine the above.
I already explained how HHH does this previously.
That you still disagree that HHH does determine
this will not be tolerated.
Le 07/11/2026 |a 19:09, olcott a |-crit :
On 11/7/2026 11:47 AM, Python wrote:
Peter,
YOU SAID GOODBYE.
And yet here you are again, repeating the SAME FUCKING QUOTATION.
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES, PETER. I SAID THAT.
AND I STAND BY THOSE EXACT WORDS.
What I do NOT accept is your claim that this establishes the
correctness of HHH's non-halting verdict.
That part is OK to disagree with.
The part that is not OK to disagree with is
that HHH does not correctly determine the above.
I already explained how HHH does this previously.
That you still disagree that HHH does determine
this will not be tolerated.
Peter,
-a-a "That you still disagree that HHH does determine
-a-a-a this will not be tolerated."
WILL NOT BE TOLERATED?
Who the fuck do you think you are?
This is a technical discussion, not a courtroom in which you get to
declare objections inadmissible.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
And we have something considerably more substantial than your repeated assertions.--
WE HAVE A CONCRETE COUNTEREXAMPLE TO YOUR DETECTOR.
Remember this program?
```c
typedef void (*fn)(unsigned);
void F(unsigned);
void G(unsigned);
void Done(unsigned);
void Done(unsigned n) { (void)n; }
void G(unsigned n)
{
-a-a fn next[2] = { F, Done };
-a-a fn p = next[n];
-a-a p(n + 1);
}
void F(unsigned n) { G(n); }
void P(void) { F(0); }
```
Its execution is straightforward:
-a-a P()
-a-a-a-a F(0)
-a-a-a-a-a-a G(0)
-a-a-a-a-a-a-a-a F(1)
-a-a-a-a-a-a-a-a-a-a G(1)
-a-a-a-a-a-a-a-a-a-a-a-a Done(2)
Then everything returns.
THE PROGRAM HALTS.
Yet the same direct call from F to G occurs twice.
Your detector looks for repeated call instructions with matching
addresses and targets, without checking the complete computational state.
That is NOT sufficient to establish infinite recursion.
And when you tested this example, you reported that HHH returned 0.
When I explained that the program actually terminates, you replied:
-a-a "Then it is simply outside the domain of HHH."
HOW CONVENIENT.
Your detector reports non-halting.
The program halts.
And suddenly the program is outside your domain.
That is not a proof of correctness.
That is moving the goalposts.
If HHH is a partial termination analyzer, DEFINE ITS DOMAIN IN ADVANCE
and demonstrate that every definitive answer within that domain is correct.
If HHH claims to decide DD correctly, explain why its actual detection criterion is sound for DD.
And stop confusing these statements:
-a-a DD has not returned during the observed simulation.
-a-a DD can never return.
THEY ARE NOT THE SAME CLAIM.
Your detector has already demonstrated why this distinction matters.
So instead of telling me what disagreement you will or will not
"tolerate", answer one concrete question:
WHAT PROPERTY OF THE COMPLETE COMPUTATIONAL STATE DOES YOUR DETECTOR ESTABLISH THAT MAKES FUTURE TERMINATION IMPOSSIBLE?
Not another quotation.
Not another declaration of self-evidence.
Not another accusation of lying.
AN ACTUAL TECHNICAL ANSWER.
Peter,
YOU HAVE JUST IGNORED THE ENTIRE TECHNICAL COUNTEREXAMPLE.
Not one word about the C program.--
Not one word about its demonstrable termination.
Not one word about your own report that HHH returned 0.
Not one word about your subsequent excuse:
-a-a "Then it is simply outside the domain of HHH."
Instead, you quote me AGAIN:
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a DD DOES NOT REACH ITS RETURN."
YES. WE FUCKING KNOW.
That quotation does not make the counterexample disappear.
YOUR DETECTOR IDENTIFIES A REPEATED CALL PATTERN IN A PROGRAM THAT TERMINATES.
YOU REPORTED A NON-HALTING VERDICT FOR THAT PROGRAM.
THEN YOU RETROACTIVELY EXCLUDED IT FROM YOUR DOMAIN.
Those are concrete technical facts that your latest reply does
absolutely nothing to address.
And this:
-a-a "Anyone that is not a damned liar and has sufficient
-a-a-a technical competence can see exactly how HHH(DD)
-a-a-a determines this. Everyone else can fuck off."
is not a technical response.
It is an attempt to replace mathematical justification with abuse.
YOU are the person claiming to have refuted the Halting Theorem.
YOU are the person whose detector has been challenged with a terminating program.
YOU are the person who must establish the correctness of its decisions.
Calling everyone else a liar does not discharge that burden.
So I will ask ONE question, and ONE question only:
-a-a WHY DID YOUR HHH RETURN 0 FOR A PROGRAM
-a-a THAT PROVABLY TERMINATES?
Either explain the result, identify an error in the test, or specify a previously established restriction that excludes the program.
But stop hiding behind my quotation.
I AM NOT YOUR FUCKING ALIBI.
Le 07/11/2026 |a 19:09, olcott a |-crit :
On 11/7/2026 11:47 AM, Python wrote:
Peter,
YOU SAID GOODBYE.
And yet here you are again, repeating the SAME FUCKING QUOTATION.
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES, PETER. I SAID THAT.
AND I STAND BY THOSE EXACT WORDS.
What I do NOT accept is your claim that this establishes the
correctness of HHH's non-halting verdict.
That part is OK to disagree with.
The part that is not OK to disagree with is
that HHH does not correctly determine the above.
I already explained how HHH does this previously.
That you still disagree that HHH does determine
this will not be tolerated.
Peter,
-a-a "That you still disagree that HHH does determine
-a-a-a this will not be tolerated."
WILL NOT BE TOLERATED?
Who the fuck do you think you are?
This is a technical discussion, not a courtroom in which you get to--
declare objections inadmissible.
And we have something considerably more substantial than your repeated assertions.
WE HAVE A CONCRETE COUNTEREXAMPLE TO YOUR DETECTOR.
Remember this program?
```c
typedef void (*fn)(unsigned);
void F(unsigned);
void G(unsigned);
void Done(unsigned);
void Done(unsigned n) { (void)n; }
void G(unsigned n)
{
-a-a fn next[2] = { F, Done };
-a-a fn p = next[n];
-a-a p(n + 1);
}
void F(unsigned n) { G(n); }
void P(void) { F(0); }
```
Its execution is straightforward:
-a-a P()
-a-a-a-a F(0)
-a-a-a-a-a-a G(0)
-a-a-a-a-a-a-a-a F(1)
-a-a-a-a-a-a-a-a-a-a G(1)
-a-a-a-a-a-a-a-a-a-a-a-a Done(2)
Then everything returns.
THE PROGRAM HALTS.
Yet the same direct call from F to G occurs twice.
Your detector looks for repeated call instructions with matching
addresses and targets, without checking the complete computational state.
That is NOT sufficient to establish infinite recursion.
And when you tested this example, you reported that HHH returned 0.
When I explained that the program actually terminates, you replied:
-a-a "Then it is simply outside the domain of HHH."
HOW CONVENIENT.
Your detector reports non-halting.
The program halts.
And suddenly the program is outside your domain.
That is not a proof of correctness.
That is moving the goalposts.
If HHH is a partial termination analyzer, DEFINE ITS DOMAIN IN ADVANCE
and demonstrate that every definitive answer within that domain is correct.
If HHH claims to decide DD correctly, explain why its actual detection criterion is sound for DD.
And stop confusing these statements:
-a-a DD has not returned during the observed simulation.
-a-a DD can never return.
THEY ARE NOT THE SAME CLAIM.
Your detector has already demonstrated why this distinction matters.
So instead of telling me what disagreement you will or will not
"tolerate", answer one concrete question:
WHAT PROPERTY OF THE COMPLETE COMPUTATIONAL STATE DOES YOUR DETECTOR ESTABLISH THAT MAKES FUTURE TERMINATION IMPOSSIBLE?
Not another quotation.
Not another declaration of self-evidence.
Not another accusation of lying.
AN ACTUAL TECHNICAL ANSWER.
Peter,
-a-a "A person that will not tolerate abuse."
OH, FOR FUCK'S SAKE.
You have spent years calling people liars, dishonest, incompetent, and accusing them of playing "sadistic head games" whenever they challenge
your arguments.
And now YOU are the victim of abuse?
GIVE ME A FUCKING BREAK.
But let's get to the mathematics, because your latest message contains a rather spectacular admission.
You write:
-a-a "The difficult theory of computation steps are
-a-a-a showing exactly how HHH(DD)==0 is correct"
EXACTLY, PETER.
THAT IS THE FUCKING QUESTION I HAVE BEEN ASKING YOU.
FOR YEARS.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
You have finally identified the very thing you have consistently failed
to demonstrate.
Nobody disputes that HHH can observe a call to HHH(DD) during its
simulation of DD.
Nobody disputes that a simulator can recognize repeated call instructions.
Nobody disputes that DD has not reached its return statement during the observed execution prefix.
WHAT WE DISPUTE IS YOUR CLAIM THAT THESE OBSERVATIONS ESTABLISH A
CORRECT NON-HALTING VERDICT.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
And your own implementation gives us a very good reason to dispute it.
REMEMBER THE COUNTEREXAMPLE YOU KEEP IGNORING?
-a-a P()
-a-a-a-a F(0)
-a-a-a-a-a-a G(0)
-a-a-a-a-a-a-a-a F(1)
-a-a-a-a-a-a-a-a-a-a G(1)
-a-a-a-a-a-a-a-a-a-a-a-a Done(2)
THE PROGRAM TERMINATES.
Peter,
-a-a "A dishonest dodge away from the domain of HHH.
-a-a-a I am only claiming that HHH(DD)==0 is correct."
OH, FOR FUCK'S SAKE.
So NOW you are only claiming that HHH correctly decides ONE PARTICULAR PROGRAM?
FINE.
Then stop pretending that the existence of HHH constitutes a refutation
of the Halting Theorem.
The theorem does not prohibit an algorithm from correctly deciding the halting behavior of one particular program.
Or ten programs.
Or infinitely many programs belonging to some restricted class.
THAT HAS NEVER BEEN IN DISPUTE.
But there is still a problem with your particular claim.
You say HHH correctly determines that DD does not halt.
HOW?
You repeatedly answer by pointing out that DD calls HHH(DD) during the simulation.
YES, PETER.
WE KNOW.
You then point out that the same call instruction is encountered again.
YES, PETER.
WE KNOW THAT TOO.
And you quote me for the hundredth fucking time:
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
I AGREED TO THAT OBSERVATION.
WHAT I HAVE NOT AGREED TO IS THAT YOUR DETECTOR'S OBSERVATION
CONSTITUTES A SOUND PROOF OF NON-TERMINATION.
And the reason is concrete.
YOUR DETECTOR'S CALL-PATTERN CRITERION IS NOT GENERALLY SOUND.
We demonstrated that with a terminating program.
You reported HHH returning 0.
Then you excluded the program from your domain.
Now you call mentioning that counterexample a "dishonest dodge".
NO.
It is a direct challenge to the soundness of the inference rule your implementation uses.
Of course, a detector that fails on another program might still give the correct answer for DD.
BUT YOU HAVE TO PROVE THAT.
You cannot simply assume that an unsound general criterion becomes sound whenever the input happens to be DD.
You need a DD-SPECIFIC ARGUMENT.
And that argument must distinguish:
-a-a HHH observes DD invoking a nested HHH.
from:
-a-a HHH proves that DD cannot terminate.
Those are not identical propositions.
Your outer HHH can terminate its simulation without the nested HHH
returning anything to DD.
ABORTING THE SIMULATION IS NOT THE SAME AS COMPLETING THE SIMULATED COMPUTATION.
Now about your latest appeal to Emil Post.
You write:
-a-a "Because Post canonical systems are Turing-equivalent,
-a-a-a anything that cannot be derived by applying finite
-a-a-a string transformations to finite string inputs is
-a-a-a outside of the domain of Church-Turing computable
-a-a-a functions."
This does not rescue your argument.
Turing equivalence establishes equivalence of computational power.
Peter,
-a-a "A specific isomorphism of an input that does
-a-a-a the opposite of whatever value its decider returns."
ISOMORPHISM?
DO YOU EVEN KNOW WHAT THAT WORD MEANS?
An isomorphism is a bijection between mathematical structures that
preserves the relevant structure.
So tell us:
WHAT ARE THE TWO STRUCTURES?
Peter,
-a-a "What-ever input is encoded to do the opposite
-a-a-a of what its decider reports <is> the HP
-a-a-a counter-example input."
THAT IS NOT AN ISOMORPHISM.
On 11/8/2026 3:40 PM, Python wrote:
Peter,
-a-a "What-ever input is encoded to do the opposite
-a-a-a of what its decider reports <is> the HP
-a-a-a counter-example input."
THAT IS NOT AN ISOMORPHISM.
Isomorphic (from Greek isos meaning "equal" and
morph-o meaning "form" or "shape") generally means
having identical or similar form, shape, or structure.
Le 08/11/2026 |a 22:45, olcott a |-crit :
On 11/8/2026 3:40 PM, Python wrote:
Peter,
-a-a-a "What-ever input is encoded to do the opposite
-a-a-a-a of what its decider reports <is> the HP
-a-a-a-a counter-example input."
THAT IS NOT AN ISOMORPHISM.
Isomorphic (from Greek isos meaning "equal" and
morph-o meaning "form" or "shape") generally means
having identical or similar form, shape, or structure.
OH, FOR FUCK'S SAKE.
I asked you to DEFINE THE MATHEMATICAL ISOMORPHISM YOU CLAIM EXISTS.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
Peter,
First, I am sorry to hear about your cancer and pneumonia. I sincerely
hope your recovery continues.
Now, FINALLY, you have numbered your argument.
GOOD.
That makes it possible to identify the precise logical error.
You write:
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT REACH ITS RETURN.
Agreed, with exactly that qualification.
Then:
-a-a (3) HHH does correctly determine this.
For the sake of argument, GRANTED.
HHH can recognize that DD has not reached its return during the observed simulation.
Now look at the actual condition in your Sipser quotation:
-a-a "H correctly determines that its simulated D
-a-a-a would NEVER stop running UNLESS aborted"
NEVER, PETER.
Peter,
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a (AKA has not been aborted)
-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
Peter,DD does not reach its return.
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a (AKA has not been aborted)
-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
Now compare:
-a-a WHILE the simulation continues,
-a-a DD does not reach its return.
with:
WHILE the simulation (has not been aborted),
Suppose there is a decider H that takes a finite
string of source code S. H applies inference steps
to S according to the operational semantics of the
language of S.
What exactly would that entail?
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a (AKA has not been aborted)
-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
(AKA has not been aborted)
(AKA has not been aborted)
(AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Le 08/11/2026 |a 23:55, olcott a |-crit :
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a (AKA has not been aborted)
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
-a (AKA has not been aborted)
-a (AKA has not been aborted)
-a (AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Peter,
-a-a "(AKA has not been aborted)"
-a-a "(AKA has not been aborted)"
-a-a "(AKA has not been aborted)"
Yes, Peter. I CAN READ.
Now YOU try reading the sentence you keep quoting:
-a-a "H correctly determines that its simulated D
-a-a-a would NEVER stop running unless aborted"
The crucial words are:
-a-a CORRECTLY DETERMINES
-a-a WOULD NEVER STOP RUNNING
Not merely:
-a-a UNLESS ABORTED
You have to PROVE that [the simulated] DD would never terminate if the simulation were
allowed to continue.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
On 11/9/2026 3:07 AM, Python wrote:
Le 08/11/2026 |a 23:55, olcott a |-crit :
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a (AKA has not been aborted)
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
-a (AKA has not been aborted)
-a (AKA has not been aborted)
-a (AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Peter,
-a-a "(AKA has not been aborted)"
-a-a "(AKA has not been aborted)"
-a-a "(AKA has not been aborted)"
Yes, Peter. I CAN READ.
Now YOU try reading the sentence you keep quoting:
-a-a "H correctly determines that its simulated D
-a-a-a would NEVER stop running unless aborted"
The crucial words are:
-a-a CORRECTLY DETERMINES
-a-a WOULD NEVER STOP RUNNING
Not merely:
-a-a UNLESS ABORTED
You have to PROVE that [the simulated] DD would never terminate if the
simulation were
allowed to continue.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
That's what those words mean.
reaching its return means halting
halting means stops running.
Le 09/11/2026 |a 14:53, olcott a |-crit :
On 11/9/2026 3:07 AM, Python wrote:
Le 08/11/2026 |a 23:55, olcott a |-crit :
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a (AKA has not been aborted)
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
-a (AKA has not been aborted)
-a (AKA has not been aborted)
-a (AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Peter,
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
Yes, Peter. I CAN READ.
Now YOU try reading the sentence you keep quoting:
-a-a-a "H correctly determines that its simulated D
-a-a-a-a would NEVER stop running unless aborted"
The crucial words are:
-a-a-a CORRECTLY DETERMINES
-a-a-a WOULD NEVER STOP RUNNING
Not merely:
-a-a-a UNLESS ABORTED
You have to PROVE that [the simulated] DD would never terminate if
the simulation were allowed to continue.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
That's what those words mean.
reaching its return means halting
halting means stops running.
Peter,
-a-a "reaching its return means halting
-a-a-a halting means stops running."
CONGRATULATIONS.
You have successfully explained what "halting" means.
Now try understanding what "WHILE" means.
I wrote:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
That describes what happens DURING the simulation.
Le 09/11/2026 |a 14:53, olcott a |-crit :
On 11/9/2026 3:07 AM, Python wrote:
Le 08/11/2026 |a 23:55, olcott a |-crit :
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a (AKA has not been aborted)
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
-a (AKA has not been aborted)
-a (AKA has not been aborted)
-a (AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Peter,
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
Yes, Peter. I CAN READ.
Now YOU try reading the sentence you keep quoting:
-a-a-a "H correctly determines that its simulated D
-a-a-a-a would NEVER stop running unless aborted"
The crucial words are:
-a-a-a CORRECTLY DETERMINES
-a-a-a WOULD NEVER STOP RUNNING
Not merely:
-a-a-a UNLESS ABORTED
You have to PROVE that [the simulated] DD would never terminate if
the simulation were allowed to continue.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
That's what those words mean.
reaching its return means halting
halting means stops running.
Peter,
-a-a "reaching its return means halting
-a-a-a halting means stops running."
CONGRATULATIONS.
You have successfully explained what "halting" means.
Now try understanding what "WHILE" means.
I wrote:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
That describes what happens DURING the simulation.
On 11/9/2026 8:15 AM, Python wrote:
Le 09/11/2026 |a 14:53, olcott a |-crit :
On 11/9/2026 3:07 AM, Python wrote:
Le 08/11/2026 |a 23:55, olcott a |-crit :
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a (AKA has not been aborted)
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
-a (AKA has not been aborted)
-a (AKA has not been aborted)
-a (AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Peter,
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
Yes, Peter. I CAN READ.
Now YOU try reading the sentence you keep quoting:
-a-a-a "H correctly determines that its simulated D
-a-a-a-a would NEVER stop running unless aborted"
The crucial words are:
-a-a-a CORRECTLY DETERMINES
-a-a-a WOULD NEVER STOP RUNNING
Not merely:
-a-a-a UNLESS ABORTED
You have to PROVE that [the simulated] DD would never terminate if
the simulation were allowed to continue.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
That's what those words mean.
reaching its return means halting
halting means stops running.
Peter,
-a-a "reaching its return means halting
-a-a-a halting means stops running."
CONGRATULATIONS.
You have successfully explained what "halting" means.
Now try understanding what "WHILE" means.
I wrote:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
That describes what happens DURING the simulation.
unless [simulation is] aborted
means
while being simulated
I don't see how you don't get this AND are honest.
Le 09/11/2026 |a 15:47, olcott a |-crit :
On 11/9/2026 8:15 AM, Python wrote:
Le 09/11/2026 |a 14:53, olcott a |-crit :
On 11/9/2026 3:07 AM, Python wrote:
Le 08/11/2026 |a 23:55, olcott a |-crit :
On 11/8/2026 4:31 PM, Python wrote:
Peter,
-a-a-a "WHILE THE SIMULATION CONTINUES,
-a-a-a-a (AKA has not been aborted)
-a-a-a-a DD DOES NOT REACH ITS RETURN."
YES.
FOR THE HUNDREDTH FUCKING TIME, YES.
I agree with those exact words.
-a (AKA has not been aborted)
-a (AKA has not been aborted)
-a (AKA has not been aborted)
H correctly determines that its simulated D
would never stop running unless aborted then
Maybe you just have a hard time paying close attention?
Peter,
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
-a-a-a "(AKA has not been aborted)"
Yes, Peter. I CAN READ.
Now YOU try reading the sentence you keep quoting:
-a-a-a "H correctly determines that its simulated D
-a-a-a-a would NEVER stop running unless aborted"
The crucial words are:
-a-a-a CORRECTLY DETERMINES
-a-a-a WOULD NEVER STOP RUNNING
Not merely:
-a-a-a UNLESS ABORTED
You have to PROVE that [the simulated] DD would never terminate if
the simulation were allowed to continue.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
That's what those words mean.
reaching its return means halting
halting means stops running.
Peter,
-a-a-a "reaching its return means halting
-a-a-a-a halting means stops running."
CONGRATULATIONS.
You have successfully explained what "halting" means.
Now try understanding what "WHILE" means.
I wrote:
-a-a-a WHILE THE SIMULATION CONTINUES,
-a-a-a DD DOES NOT REACH ITS RETURN.
That describes what happens DURING the simulation.
unless [simulation is] aborted
means
while being simulated
I don't see how you don't get this AND are honest.
Peter,
-a-a "unless [simulation is] aborted
-a-a-a means
-a-a-a while being simulated"
FINE.
LET'S GRANT THAT.
Now explain how:
-a-a DD DOES NOT RETURN WHILE BEING SIMULATED
logically implies:
-a-a DD WOULD NEVER RETURN IF THE SIMULATION
-a-a WERE ALLOWED TO CONTINUE WITHOUT ABORTION.
THAT IS THE QUESTION.
Peter,
-a-a "simulated D would never stop running
-a-a-a unless [simulation is] aborted"
becomes:
-a-a "simulated D would never stop running
-a-a-a while being simulated"
FINE.
And now?
You have merely REPHRASED THE SAME CLAIM.
You have not PROVED IT.
The words "would never stop running" are precisely the part that
requires justification.
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a "simulated D would never stop running
-a-a-a unless [simulation is] aborted"
becomes:
-a-a "simulated D would never stop running
-a-a-a while being simulated"
FINE.
And now?
You have merely REPHRASED THE SAME CLAIM.
You have not PROVED IT.
The words "would never stop running" are precisely the part that
requires justification.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
You already conceded that.
Does not reach its return means never halts
would never stop running means never halts
Peter,
-a-a "simulated D would never stop running
-a-a-a unless [simulation is] aborted"
becomes:
-a-a "simulated D would never stop running
-a-a-a while being simulated"
FINE.
And now?
Le 09/11/2026 |a 16:43, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
You have merely REPHRASED THE SAME CLAIM.
You have not PROVED IT.
The words "would never stop running" are precisely the part that
requires justification.
On 11/2/2026 8:50 AM, Python wrote:
WHILE THE SIMULATION CONTINUES,
DD DOES NOT REACH ITS RETURN.
You already conceded that.
Does not reach its return means never halts
would never stop running means never halts
Peter,
-a-a "You already conceded that."
NO.
I conceded EXACTLY this:
-a-a WHILE THE SIMULATION CONTINUES,
-a-a DD DOES NOT REACH ITS RETURN.
You now write:
-a-a "Does not reach its return means never halts"
WHERE THE FUCK DID "NEVER" COME FROM?
A program that has not reached its return YET may reach it later.
A simulation that has been aborted cannot tell us, merely from its lack
of a return before abortion, whether the simulated program would
eventually halt.
You keep silently deleting the qualification from my statement, then pretending I agreed with your stronger conclusion.
I DID NOT.
And there is an even more fundamental distinction you keep ignoring:
When the OUTER HHH aborts its simulation of DD, that does not mean the
INNER HHH has returned a value to DD.
Those are DIFFERENT invocations.
So, once again:
What EXACT property of DD's execution proves that it would never reach
its return if the simulation continued without abortion?
Not a quotation from me.
Not a definition of "halt".
Not another paraphrase of "unless aborted".
A PROOF.
Until you provide one, your claim that HHH correctly determines DD's non-termination remains unsupported.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a "simulated D would never stop running
-a-a-a unless [simulation is] aborted"
becomes:
-a-a "simulated D would never stop running
-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
is translated into
"simulated D would never stop running while being simulated"
[would never stop running]
is translated into
never halts
[simulated D would never stop running unless aborted]
becomes
"simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
> WHILE THE SIMULATION CONTINUES,
> DD DOES NOT REACH ITS RETURN.
>
[REACH ITS RETURN]
is translated into
HALT
On 11/2/2026 8:50 AM, Python wrote:
> WHILE THE SIMULATION CONTINUES,
> DD DOES NOT REACH ITS RETURN.
>
is translated into
WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Consider a simulation stopped after 100 steps of a program that wouldRight! PO would chops the legs off a runner saying it was running into infinity. The runner, with no legs now, says I was running to the god
halt after 1,000 steps.
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a (1) Simulated D would never halt
-a-a-a-a-a-a while being simulated.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
I HAVE NO OBJECTION TO THAT.
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a (1) Simulated D would never halt
-a-a-a-a-a-a while being simulated.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
I HAVE NO OBJECTION TO THAT.
So we are done.
I translated what what Professor Sipser agreed to into (1)
and I translated what what you agreed to into (2)
Le 10/11/2026 |a 00:14, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
I HAVE NO OBJECTION TO THAT.
So we are done.
I translated what what Professor Sipser agreed to into (1)
and I translated what what you agreed to into (2)
Peter,
-a-a "So we are done."
NO, YOU FUCKING IDIOT.
You have established that two sentences CAN mean the same thing.
On 11/9/2026 5:35 PM, Python wrote:
Le 10/11/2026 |a 00:14, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly. >>>>
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
I HAVE NO OBJECTION TO THAT.
So we are done.
I translated what what Professor Sipser agreed to into (1)
and I translated what what you agreed to into (2)
Peter,
-a-a "So we are done."
NO, YOU FUCKING IDIOT.
You have established that two sentences CAN mean the same thing.
The one that you agreed to and the one that
satisfies the Professor Sipser approved criteria.
Le 10/11/2026 |a 00:55, olcott a |-crit :
On 11/9/2026 5:35 PM, Python wrote:
Le 10/11/2026 |a 00:14, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared
directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
I HAVE NO OBJECTION TO THAT.
So we are done.
I translated what what Professor Sipser agreed to into (1)
and I translated what what you agreed to into (2)
Peter,
-a-a-a "So we are done."
NO, YOU FUCKING IDIOT.
You have established that two sentences CAN mean the same thing.
The one that you agreed to and the one that
satisfies the Professor Sipser approved criteria.
Peter,
NO, FOR FUCK'S SAKE!
On 11/9/2026 5:59 PM, Python wrote:
Le 10/11/2026 |a 00:55, olcott a |-crit :(1) Was correctly derived from the Professor Sipser approved exact words
On 11/9/2026 5:35 PM, Python wrote:
Le 10/11/2026 |a 00:14, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared
directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
I HAVE NO OBJECTION TO THAT.
So we are done.
I translated what what Professor Sipser agreed to into (1)
and I translated what what you agreed to into (2)
Peter,
-a-a-a "So we are done."
NO, YOU FUCKING IDIOT.
You have established that two sentences CAN mean the same thing.
The one that you agreed to and the one that
satisfies the Professor Sipser approved criteria.
Peter,
NO, FOR FUCK'S SAKE!
(2) Was derived from your exact words.
No meanings were changed, just a change of words.
You agreed that (1) and (2) have the same meaning.
FOR FUCK'S SAKE!
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a (1) Simulated D would never halt
-a-a-a-a-a-a while being simulated.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :That is too weak. Does mean exactly the same thing.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a (1) Simulated D would never halt
-a-a-a-a-a-a while being simulated.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Le 10/11/2026 |a 01:38, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :That is too weak. Does mean exactly the same thing.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Peter,
-a-a "Does mean exactly the same thing."
BULLSHIT.
And STOP SNIPPING MY REPLIES to conceal the qualifications you keep ignoring.
I wrote:
-a-a "As English sentences, these CAN express
-a-a-a the same proposition."
CAN, Peter. NOT NECESSARILY DO.
My statement concerned the FINITE SIMULATION ACTUALLY PERFORMED.--
Sipser's hypothesis concerns what WOULD HAPPEN if the simulation
continued WITHOUT ABORTION, and requires H to CORRECTLY DETERMINE that outcome.
You have silently changed the scope of my statement, then pretended I endorsed your conclusion.
THAT IS NOT LOGICAL DERIVATION.
THAT IS FALSIFICATION.
And even if your two sentences were perfectly equivalent, their
equivalence would NOT prove their truth.
FOR FUCK'S SAKE.
STOP CHERRY-PICKING MY WORDS.
STOP MISREPRESENTING MY AGREEMENT.
AND PRODUCE THE FUCKING PROOF THAT HHH CORRECTLY DETERMINES NON- TERMINATION.
On 11/9/2026 6:40 PM, Python wrote:
Le 10/11/2026 |a 01:38, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :That is too weak. Does mean exactly the same thing.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly. >>>>
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Peter,
-a-a "Does mean exactly the same thing."
BULLSHIT.
And STOP SNIPPING MY REPLIES to conceal the qualifications you keep
ignoring.
I wrote:
-a-a "As English sentences, these CAN express
-a-a-a the same proposition."
CAN, Peter. NOT NECESSARILY DO.
Try and show a valid counter-example that categorically
cannot possibly exist.
Le 09/11/2026 |a 19:18, olcott a |-crit :
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a (1) Simulated D would never halt
-a-a-a-a-a-a while being simulated.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a (1) Simulated D would never halt
-a-a-a-a-a-a while being simulated.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
Now evaluate:--
-a-a (1) Simulated D would NEVER halt while being simulated.
FALSE. Continue the simulation for another 900 steps and D halts.
-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a D DOES NOT HALT.
TRUE of the simulation actually performed: D does not halt during those
100 steps.
THERE IS YOUR COUNTEREXAMPLE.
One proposition concerns a finite execution actually observed.
The other concerns what would happen if execution continued without abortion.
If you interpret BOTH propositions as referring to an unlimited
execution, then yes, they are equivalent.
BUT THAT IS NOT WHAT I AGREED TO.
You have been told this repeatedly.
And before you start screaming that my example is not DD: it is a counterexample to your CLAIMED LOGICAL EQUIVALENCE, not a proof that DD halts.
If you want to establish non-termination specifically for DD, PROVIDE
THE FUCKING PROOF.
You cannot manufacture my agreement by systematically ignoring what I actually said.
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly. >>>>
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared
directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND
IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a "There does not exist ANY implementation..."
-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES.
You have transformed that into a universal claim about EVERY possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted]
-a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared
directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND
IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a "There does not exist ANY implementation..."
-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES. >>
You have transformed that into a universal claim about EVERY possible
implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition whose
derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared
directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND >>> IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a "There does not exist ANY implementation..."
-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES. >>>
You have transformed that into a universal claim about EVERY possible
implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition whose >>> derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify PRECISELY what
additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated"
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared
directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY possible
implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition
whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition--
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
Le 10/11/2026 |a 17:16, Python a |-crit :
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition
whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that
quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode:
-a-a int HHH(ptr P)
-a-a {
-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a depth++;
-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a depth--;
-a-a-a-a-a-a return 1;
-a-a }
Here, simulate(P) faithfully simulates the execution of P, including the code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
1. The outer HHH(DD) increments depth to 1 and starts simulating DD.
2. The simulated DD invokes HHH(DD).
3. This simulated invocation sees depth == 1 and returns 0.
4. The simulated DD does not enter its infinite loop.
5. The simulated DD reaches its return statement.
6. The outer HHH completes its simulation and returns 1.
SAME implementation of HHH.
SAME source code of DD.
Faithful simulation according to the operational semantics of C.
And DD reaches its simulated return statement in a finite number of steps.
This is NOT a universal halt decider.
IT DOES NOT NEED TO BE ONE.
Your proposition quantifies over ANY implementation of HHH that
simulates DD.
If you require HHH to satisfy additional properties, STATE THEM.
In particular, if you require every invocation of HHH to be a correct
halt decider, you are introducing a condition that your original
proposition did not contain.
And if you require a total, universally correct halt decider, you are
back to the impossible hypothesis of the Halting Theorem.
There is no mystery here.
Different invocations of the SAME function can behave differently
because they execute in different states.
This is elementary programming.
Your universal claim, as stated, is FALSE.
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>>
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition
whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that
quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode:
-a-a int HHH(ptr P)
-a-a {
-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a depth++;
-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a depth--;
-a-a-a-a-a-a return 1;
-a-a }
Here, simulate(P) faithfully simulates the execution of P, including the
code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
1. The outer HHH(DD) increments depth to 1 and starts simulating DD.
2. The simulated DD invokes HHH(DD).
3. This simulated invocation sees depth == 1 and returns 0.
4. The simulated DD does not enter its infinite loop.
5. The simulated DD reaches its return statement.
6. The outer HHH completes its simulation and returns 1.
SAME implementation of HHH.
SAME source code of DD.
Faithful simulation according to the operational semantics of C.
And DD reaches its simulated return statement in a finite number of steps. >>
This is NOT a universal halt decider.
IT DOES NOT NEED TO BE ONE.
Your proposition quantifies over ANY implementation of HHH that
simulates DD.
If you require HHH to satisfy additional properties, STATE THEM.
In particular, if you require every invocation of HHH to be a correct
halt decider, you are introducing a condition that your original
proposition did not contain.
And if you require a total, universally correct halt decider, you are
back to the impossible hypothesis of the Halting Theorem.
There is no mystery here.
Different invocations of the SAME function can behave differently
because they execute in different states.
This is elementary programming.
Your universal claim, as stated, is FALSE.
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
So do you agree with that now? I have an 8 hour infusion
today thus no time to go over tiny details.
Le 10/11/2026 |a 17:31, olcott a |-crit :
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being >>>>>>>>>>> simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>
(1) "simulated D would never halt while being simulated" >>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much >>>>>> stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR
DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition >>>>>> whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict
that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode:
-a-a-a int HHH(ptr P)
-a-a-a {
-a-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a-a depth++;
-a-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a-a depth--;
-a-a-a-a-a-a-a return 1;
-a-a-a }
Here, simulate(P) faithfully simulates the execution of P, including
the code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
1. The outer HHH(DD) increments depth to 1 and starts simulating DD.
2. The simulated DD invokes HHH(DD).
3. This simulated invocation sees depth == 1 and returns 0.
4. The simulated DD does not enter its infinite loop.
5. The simulated DD reaches its return statement.
6. The outer HHH completes its simulation and returns 1.
SAME implementation of HHH.
SAME source code of DD.
Faithful simulation according to the operational semantics of C.
And DD reaches its simulated return statement in a finite number of
steps.
This is NOT a universal halt decider.
IT DOES NOT NEED TO BE ONE.
Your proposition quantifies over ANY implementation of HHH that
simulates DD.
If you require HHH to satisfy additional properties, STATE THEM.
In particular, if you require every invocation of HHH to be a correct
halt decider, you are introducing a condition that your original
proposition did not contain.
And if you require a total, universally correct halt decider, you are
back to the impossible hypothesis of the Halting Theorem.
There is no mystery here.
Different invocations of the SAME function can behave differently
because they execute in different states.
This is elementary programming.
Your universal claim, as stated, is FALSE.
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
So do you agree with that now? I have an 8 hour infusion
today thus no time to go over tiny details.
Peter,
-a-a "So do you agree with that now?"
NO.
WHAT THE FUCK?
Le 10/11/2026 |a 17:16, Python a |-crit :
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>>> -a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition.
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition
whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that
quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode:
-a-a int HHH(ptr P)
-a-a {
-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a depth++;
-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a depth--;
-a-a-a-a-a-a return 1;
-a-a }
Here, simulate(P) faithfully simulates the execution of P, including the code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :int HHHH(ptr P);
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted]
-a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
(1) "simulated D would never halt while being simulated"
(2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much
stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>>
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition
whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that
quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode:
-a-a int HHH(ptr P)
-a-a {
-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a depth++;
-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a depth--;
-a-a-a-a-a-a return 1;
-a-a }
Here, simulate(P) faithfully simulates the execution of P, including the
code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
int DDDD()
{
int Halt_Status = HHHH(DDDD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int simulateXXX(ptr P)
{
P();
return 1;
}
int HHHH(ptr P)
{
static int depth = 0;
if (depth > 0)
return 0;
depth++;
simulateXXX(P);
depth--;
return 1;
}
int main()
{
Output("Input_Halts = ", HHHH(DDDD));
return 0;
}
I can give the the machine code trace.
It is quite verbose. The simulated DDDD
never reaches its own simulated return
and HHHH returns the correct halt status.
dbush could see that the meaning of these words made them true:
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
(1) This seems dead obvious to me.
(2) The above words
*There does not exist any implementation of C function HHH*
that dbush composed are better than my own best words.
Le 10/11/2026 |a 17:31, olcott a |-crit :[ .... ]
On 11/10/2026 10:17 AM, Python wrote:
[ .... ]Consider the following implementation, expressed in C-like pseudocode:
-a-a int HHH(ptr P)
-a-a {
-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a depth++;
-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a depth--;
-a-a-a-a-a-a return 1;
-a-a }
[ .... ]Your universal claim, as stated, is FALSE.There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,You've not yet grasped the fact that Peter Olcott doesn't understand the concept of a counterexample. His intellect is insufficiently developed
"So do you agree with that now?"
NO.
WHAT THE FUCK?
I have just provided an explicit counterexample to that very proposition.
An implementation of HHH.You might as well be screaming at a 5 year old child. He wouldn't
The SAME implementation for the outer and inner invocations.
A faithful simulation of DD according to the operational semantics of C.
And a finite execution reaching DD's simulated return statement.
You have quoted my ENTIRE counterexample and then simply repeated the proposition it refutes.
SERIOUSLY?
"no time to go over tiny details."[ .... ]
A COUNTEREXAMPLE TO YOUR UNIVERSAL CLAIM IS NOT A TINY DETAIL.
It is a refutation.
Repeating your proposition does not make it true.--
And it certainly does not make me agree with it.
Le 11/11/2026 |a 05:41, olcott a |-crit :
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :int HHHH(ptr P);
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being >>>>>>>>>>> simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>
(1) "simulated D would never halt while being simulated" >>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much >>>>>> stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION
CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR
DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.
You reject it because it does not satisfy the stronger proposition >>>>>> whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict
that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode:
-a-a-a int HHH(ptr P)
-a-a-a {
-a-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a-a depth++;
-a-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a-a depth--;
-a-a-a-a-a-a-a return 1;
-a-a-a }
Here, simulate(P) faithfully simulates the execution of P, including
the code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
int DDDD()
{
-a-a int Halt_Status = HHHH(DDDD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}
int simulateXXX(ptr P)
{
-a-a P();
-a-a return 1;
}
int HHHH(ptr P)
{
-a-a static int depth = 0;
-a-a if (depth > 0)
-a-a-a-a return 0;
-a-a depth++;
-a-a simulateXXX(P);
-a-a depth--;
-a-a return 1;
}
int main()
{
-a-a Output("Input_Halts = ", HHHH(DDDD));
-a-a return 0;
}
I can give the the machine code trace.
It is quite verbose. The simulated DDDD
never reaches its own simulated return
and HHHH returns the correct halt status.
dbush could see that the meaning of these words made them true:
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
(1) This seems dead obvious to me.
(2) The above words
*There does not exist any implementation of C function HHH*
that dbush composed are better than my own best words.
Peter,
THANK YOU.
You have just provided a concrete C program that REFUTES YOUR OWN CLAIM.
Let's execute YOUR code.
Initially:
-a-a depth = 0
The outer HHHH(DDDD) executes:
-a-a depth++;
Now:
-a-a depth = 1
Then:
-a-a simulateXXX(DDDD);
which executes:
-a-a DDDD();
Inside DDDD:
-a-a Halt_Status = HHHH(DDDD);
This nested invocation executes:
-a-a if (depth > 0)
-a-a-a-a-a-a return 0;
Since depth == 1, HHHH returns 0.
Back inside DDDD:
-a-a Halt_Status == 0
Therefore:
-a-a if (Halt_Status)
-a-a-a-a-a-a HERE: goto HERE;
does NOT enter the loop.
And the very next statement is:
-a-a return Halt_Status;
DDDD RETURNS ZERO.
The outer HHHH then decrements depth and returns 1.
So YOUR OWN PROGRAM establishes:
-a-a DDDD reaches its return statement.
-a-a HHHH(DDDD) returns 1.
-a-a Both executions terminate.
-a-a The returned halt status is correct.
And yet you write:
-a-a "The simulated DDDD never reaches
-a-a-a its own simulated return"
WHAT THE FUCK ARE YOU TALKING ABOUT?
Your simulateXXX calls DDDD directly rather than interpreting its
machine instructions. But the actual C execution is perfectly clear.
YES, PLEASE PROVIDE THE MACHINE CODE TRACE.
In particular, show us where DDDD supposedly fails to execute its return instruction.
Because according to the C code YOU JUST POSTED, it MUST reach that return.
You have managed to construct a counterexample to your own universal
claim, POST IT YOURSELF, and then declare that it proves the exact
opposite.
That is quite an achievement.
On 11/11/2026 6:23 AM, Python wrote:
Le 11/11/2026 |a 05:41, olcott a |-crit :
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :int HHHH(ptr P);
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted] >>>>>>>>>>>> -a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being >>>>>>>>>>>> simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>
(1) "simulated D would never halt while being simulated" >>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared >>>>>>>>>>> directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY >>>>>>> PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much >>>>>>> stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION >>>>>>> CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps. >>>>>>>
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR >>>>>>> DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>
You reject it because it does not satisfy the stronger proposition >>>>>>> whose derivation is precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition
instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but
whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict
that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode: >>>>
-a-a-a int HHH(ptr P)
-a-a-a {
-a-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a-a depth++;
-a-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a-a depth--;
-a-a-a-a-a-a-a return 1;
-a-a-a }
Here, simulate(P) faithfully simulates the execution of P, including
the code of HHH itself and its access to the simulated state.
The execution proceeds as follows:
int DDDD()
{
-a-a int Halt_Status = HHHH(DDDD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}
int simulateXXX(ptr P)
{
-a-a P();
-a-a return 1;
}
int HHHH(ptr P)
{
-a-a static int depth = 0;
-a-a if (depth > 0)
-a-a-a-a return 0;
-a-a depth++;
-a-a simulateXXX(P);
-a-a depth--;
-a-a return 1;
}
int main()
{
-a-a Output("Input_Halts = ", HHHH(DDDD));
-a-a return 0;
}
I can give the the machine code trace.
It is quite verbose. The simulated DDDD
never reaches its own simulated return
and HHHH returns the correct halt status.
dbush could see that the meaning of these words made them true:
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
(1) This seems dead obvious to me.
(2) The above words
*There does not exist any implementation of C function HHH*
that dbush composed are better than my own best words.
Peter,
THANK YOU.
You have just provided a concrete C program that REFUTES YOUR OWN CLAIM.
Let's execute YOUR code.
Initially:
-a-a depth = 0
The outer HHHH(DDDD) executes:
-a-a depth++;
Now:
-a-a depth = 1
Then:
-a-a simulateXXX(DDDD);
which executes:
-a-a DDDD();
Inside DDDD:
-a-a Halt_Status = HHHH(DDDD);
This nested invocation executes:
-a-a if (depth > 0)
-a-a-a-a-a-a return 0;
Since depth == 1, HHHH returns 0.
Back inside DDDD:
-a-a Halt_Status == 0
Therefore:
-a-a if (Halt_Status)
-a-a-a-a-a-a HERE: goto HERE;
does NOT enter the loop.
And the very next statement is:
-a-a return Halt_Status;
DDDD RETURNS ZERO.
The outer HHHH then decrements depth and returns 1.
So YOUR OWN PROGRAM establishes:
-a-a DDDD reaches its return statement.
-a-a HHHH(DDDD) returns 1.
-a-a Both executions terminate.
-a-a The returned halt status is correct.
And yet you write:
-a-a "The simulated DDDD never reaches
-a-a-a its own simulated return"
WHAT THE FUCK ARE YOU TALKING ABOUT?
Your simulateXXX calls DDDD directly rather than interpreting its
machine instructions. But the actual C execution is perfectly clear.
YES, PLEASE PROVIDE THE MACHINE CODE TRACE.
In particular, show us where DDDD supposedly fails to execute its return
instruction.
Because according to the C code YOU JUST POSTED, it MUST reach that return. >>
You have managed to construct a counterexample to your own universal
claim, POST IT YOURSELF, and then declare that it proves the exact
opposite.
That is quite an achievement.
_HHHH()
[000021f6] 55 push ebp
[000021f7] 8bec mov ebp,esp
[000021f9] 833d0000000000 cmp dword [00000000],+00
[00002200] 7e04 jng 00002206
[00002202] 33c0 xor eax,eax
[00002204] eb2d jmp 00002233
[00002206] a100000000 mov eax,[00000000]
[0000220b] 83c001 add eax,+01
[0000220e] a300000000 mov [00000000],eax
[00002213] 8b4d08 mov ecx,[ebp+08]
[00002216] 51 push ecx
[00002217] e84a000000 call 00002266
[0000221c] 83c404 add esp,+04
[0000221f] 8b1500000000 mov edx,[00000000]
[00002225] 83ea01 sub edx,+01
[00002228] 891500000000 mov [00000000],edx
[0000222e] b801000000 mov eax,00000001
[00002233] 5d pop ebp
[00002234] c3 ret
Size in bytes:(0063) [00002234]
_DDDD()
[00002236] 55 push ebp
[00002237] 8bec mov ebp,esp
[00002239] 51 push ecx
[0000223a] 6836220000 push 00002236
[0000223f] e8b2ffffff call 000021f6
[00002244] 83c404 add esp,+04
[00002247] 8945fc mov [ebp-04],eax
[0000224a] 837dfc00 cmp dword [ebp-04],+00
[0000224e] 7402 jz 00002252
[00002250] ebfe jmp 00002250
[00002252] 8b45fc mov eax,[ebp-04]
[00002255] 8be5 mov esp,ebp
[00002257] 5d pop ebp
[00002258] c3 ret
Size in bytes:(0035) [00002258]
_simulateXXX()
[00002266] 55 push ebp
[00002267] 8bec mov ebp,esp
[00002269] ff5508 call dword [ebp+08]
[0000226c] b801000000 mov eax,00000001
[00002271] 5d pop ebp
[00002272] c3 ret
Size in bytes:(0013) [00002272]
_main()
[00002276] 55 push ebp
[00002277] 8bec mov ebp,esp
[00002279] 6836220000 push 00002236
[0000227e] e873ffffff call 000021f6
[00002283] 83c404 add esp,+04
[00002286] 50 push eax
[00002287] 6887070000 push 00000787
[0000228c] e815e5ffff call 000007a6
[00002291] 83c408 add esp,+08
[00002294] 33c0 xor eax,eax
[00002296] 5d pop ebp
[00002297] c3 ret
Size in bytes:(0034) [00002297]
machine stack stack machine assembly
address address data code language
======== ======== ======== ============== ============= [00002276][001039d6][00000000] 55 push ebp [00002277][001039d6][00000000] 8bec mov ebp,esp [00002279][001039d2][00002236] 6836220000 push 00002236
// call HHH(DDDD) [0000227e][001039ce][00002283] e873ffffff call 000021f6 [000021f6][001039ca][001039d6] 55 push ebp [000021f7][001039ca][001039d6] 8bec mov ebp,esp [000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00 [00002200][001039ca][001039d6] 7e04 jng 00002206 [00002202][001039ca][001039d6] 33c0 xor eax,eax [00002204][001039ca][001039d6] eb2d jmp 00002233 [00002233][001039ce][00002283] 5d pop ebp [00002234][001039d2][00002236] c3 ret
// end HHHH [00002283][001039d6][00000000] 83c404 add esp,+04 [00002286][001039d2][00000000] 50 push eax [00002287][001039ce][00000787] 6887070000 push 00000787 [0000228c][001039ce][00000787] e815e5ffff call 000007a6
Input_Halts = 0
[00002291][001039d6][00000000] 83c408 add esp,+08 [00002294][001039d6][00000000] 33c0 xor eax,eax [00002296][001039da][90909090] 5d pop ebp [00002297][001039de][90909090] c3 ret
Number of Instructions Executed(19) == 0 Pages
Le 11/11/2026 |a 14:23, olcott a |-crit :
On 11/11/2026 6:23 AM, Python wrote:
Le 11/11/2026 |a 05:41, olcott a |-crit :
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :int HHHH(ptr P);
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted] >>>>>>>>>>>>> -a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being >>>>>>>>>>>>> simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>
(1) "simulated D would never halt while being simulated" >>>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be
compared directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions." >>>>>>>>>>
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches >>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>> steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY >>>>>>>> PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a >>>>>>>> much stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION >>>>>>>> CONTINUES.
You have transformed that into a universal claim about EVERY
possible implementation of HHH and EVERY finite number of steps. >>>>>>>>
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR >>>>>>>> DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>>
You reject it because it does not satisfy the stronger
proposition whose derivation is precisely what is being challenged. >>>>>>>>
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition >>>>>> instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but >>>>>> whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify
PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict >>>>>> that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH
invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode: >>>>>
-a-a-a int HHH(ptr P)
-a-a-a {
-a-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a-a depth++;
-a-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a-a depth--;
-a-a-a-a-a-a-a return 1;
-a-a-a }
Here, simulate(P) faithfully simulates the execution of P,
including the code of HHH itself and its access to the simulated
state.
The execution proceeds as follows:
int DDDD()
{
-a-a int Halt_Status = HHHH(DDDD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}
int simulateXXX(ptr P)
{
-a-a P();
-a-a return 1;
}
int HHHH(ptr P)
{
-a-a static int depth = 0;
-a-a if (depth > 0)
-a-a-a-a return 0;
-a-a depth++;
-a-a simulateXXX(P);
-a-a depth--;
-a-a return 1;
}
int main()
{
-a-a Output("Input_Halts = ", HHHH(DDDD));
-a-a return 0;
}
I can give the the machine code trace.
It is quite verbose. The simulated DDDD
never reaches its own simulated return
and HHHH returns the correct halt status.
dbush could see that the meaning of these words made them true:
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
(1) This seems dead obvious to me.
(2) The above words
*There does not exist any implementation of C function HHH*
that dbush composed are better than my own best words.
Peter,
THANK YOU.
You have just provided a concrete C program that REFUTES YOUR OWN CLAIM. >>>
Let's execute YOUR code.
Initially:
-a-a-a depth = 0
The outer HHHH(DDDD) executes:
-a-a-a depth++;
Now:
-a-a-a depth = 1
Then:
-a-a-a simulateXXX(DDDD);
which executes:
-a-a-a DDDD();
Inside DDDD:
-a-a-a Halt_Status = HHHH(DDDD);
This nested invocation executes:
-a-a-a if (depth > 0)
-a-a-a-a-a-a-a return 0;
Since depth == 1, HHHH returns 0.
Back inside DDDD:
-a-a-a Halt_Status == 0
Therefore:
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
does NOT enter the loop.
And the very next statement is:
-a-a-a return Halt_Status;
DDDD RETURNS ZERO.
The outer HHHH then decrements depth and returns 1.
So YOUR OWN PROGRAM establishes:
-a-a-a DDDD reaches its return statement.
-a-a-a HHHH(DDDD) returns 1.
-a-a-a Both executions terminate.
-a-a-a The returned halt status is correct.
And yet you write:
-a-a-a "The simulated DDDD never reaches
-a-a-a-a its own simulated return"
WHAT THE FUCK ARE YOU TALKING ABOUT?
Your simulateXXX calls DDDD directly rather than interpreting its
machine instructions. But the actual C execution is perfectly clear.
YES, PLEASE PROVIDE THE MACHINE CODE TRACE.
In particular, show us where DDDD supposedly fails to execute its
return instruction.
Because according to the C code YOU JUST POSTED, it MUST reach that
return.
You have managed to construct a counterexample to your own universal
claim, POST IT YOURSELF, and then declare that it proves the exact
opposite.
That is quite an achievement.
_HHHH()
[000021f6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[000021f7] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[000021f9] 833d0000000000 cmp dword [00000000],+00
[00002200] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
[00002202] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002204] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
[00002206] a100000000-a-a-a-a mov eax,[00000000]
[0000220b] 83c001-a-a-a-a-a-a-a-a add eax,+01
[0000220e] a300000000-a-a-a-a mov [00000000],eax
[00002213] 8b4d08-a-a-a-a-a-a-a-a mov ecx,[ebp+08]
[00002216] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002217] e84a000000-a-a-a-a call 00002266
[0000221c] 83c404-a-a-a-a-a-a-a-a add esp,+04
[0000221f] 8b1500000000-a-a mov edx,[00000000]
[00002225] 83ea01-a-a-a-a-a-a-a-a sub edx,+01
[00002228] 891500000000-a-a mov [00000000],edx
[0000222e] b801000000-a-a-a-a mov eax,00000001
[00002233] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002234] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0063) [00002234]
_DDDD()
[00002236] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002237] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002239] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[0000223a] 6836220000-a-a-a-a push 00002236
[0000223f] e8b2ffffff-a-a-a-a call 000021f6
[00002244] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002247] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[0000224a] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000224e] 7402-a-a-a-a-a-a-a-a-a-a jz 00002252
[00002250] ebfe-a-a-a-a-a-a-a-a-a-a jmp 00002250
[00002252] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002255] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002257] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002258] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002258]
_simulateXXX()
[00002266] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002267] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002269] ff5508-a-a-a-a-a-a-a-a call dword [ebp+08]
[0000226c] b801000000-a-a-a-a mov eax,00000001
[00002271] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002272] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0013) [00002272]
_main()
[00002276] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002277] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002279] 6836220000-a-a-a-a push 00002236
[0000227e] e873ffffff-a-a-a-a call 000021f6
[00002283] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002286] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
[00002287] 6887070000-a-a-a-a push 00000787
[0000228c] e815e5ffff-a-a-a-a call 000007a6
[00002291] 83c408-a-a-a-a-a-a-a-a add esp,+08
[00002294] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002296] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002297] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0034) [00002297]
-a machine-a-a stack-a-a-a-a stack-a-a-a-a machine-a-a-a-a-a-a-a assembly
-a address-a-a address-a-a data-a-a-a-a-a code-a-a-a-a-a-a-a-a-a-a language >> -a ========-a ========-a ========-a ============== =============
[00002276][001039d6][00000000] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002277][001039d6][00000000] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002279][001039d2][00002236] 6836220000-a-a-a-a push 00002236
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // call HHH(DDDD)
[0000227e][001039ce][00002283] e873ffffff-a-a-a-a call 000021f6
[000021f6][001039ca][001039d6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[000021f7][001039ca][001039d6] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00
[00002200][001039ca][001039d6] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
[00002202][001039ca][001039d6] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002204][001039ca][001039d6] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
[00002233][001039ce][00002283] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002234][001039d2][00002236] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // end HHHH
[00002283][001039d6][00000000] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002286][001039d2][00000000] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
[00002287][001039ce][00000787] 6887070000-a-a-a-a push 00000787
[0000228c][001039ce][00000787] e815e5ffff-a-a-a-a call 000007a6
Input_Halts = 0
[00002291][001039d6][00000000] 83c408-a-a-a-a-a-a-a-a add esp,+08
[00002294][001039d6][00000000] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002296][001039da][90909090] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002297][001039de][90909090] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Number of Instructions Executed(19) == 0 Pages
Peter,
THANK YOU FOR THE MACHINE CODE TRACE.
It exposes the problem immediately.
Look at YOUR trace:
-a-a 000021f9-a cmp dword [00000000],+00
-a-a 00002200-a jng 00002206
-a-a 00002202-a xor eax,eax
-a-a 00002204-a jmp 00002233
The conditional jump is NOT taken.
Therefore, the condition:
-a-a depth > 0
is TRUE at the very beginning of the OUTER HHHH invocation.
BUT YOUR SOURCE CODE DECLARES:
-a-a static int depth = 0;
At the start of the program, depth MUST be zero.
Consequently, the correct execution must take the branch to 00002206, increment depth, and call simulateXXX(DDDD).
YOUR TRACE DOES NONE OF THAT.
It immediately returns zero, without ever calling DDDD.
Indeed, your entire trace contains only 19 executed instructions!
So when you claim:
-a-a "The simulated DDDD never reaches
-a-a-a its own simulated return"
you are describing a simulation THAT NEVER EVEN STARTED.
And there is an even more obvious discrepancy.
Your trace prints:
-a-a Input_Halts = 0
But your C program, executed with its correctly initialized static
variable, prints:
-a-a Input_Halts = 1
because DDDD DOES reach its return statement.
Your trace is therefore NOT a valid execution of the C program you
presented from its specified initial state.
The most likely explanation is that your emulator has not correctly initialized the simulated static storage.
You have confused a BUG IN YOUR SIMULATOR with a mathematical
impossibility.
FOR FUCK'S SAKE, PETER.
Before claiming to have refuted the Halting Theorem, perhaps make sure
your emulator can correctly execute a static variable initialized to zero.
Please show the initial contents of the memory location corresponding to depth, and explain why the first conditional jump is not taken.
Peter,
-a-a "My HHH creates a whole separate process context
-a-a-a to simulate DD."
AND SO WHAT?
Creating a separate execution context does not magically abolish the operational semantics of C.--
You now have TWO possibilities.
CASE 1: A FRESH PROCESS CONTEXT.
The simulated program starts with its static storage correctly initialized.
Therefore:
-a-a static int depth = 0;
means depth == 0.
Your trace, however, takes the branch corresponding to depth > 0.
WHY?
CASE 2: AN INVOCATION WITHIN THE EXISTING PROCESS STATE.
The outer HHHH has already executed:
-a-a depth++;
Therefore depth == 1 when DDDD invokes HHHH.
The nested HHHH returns 0.
DDDD then reaches its return statement.
END OF STORY.
You cannot simultaneously claim that the simulated execution has a
fresh, independent process state AND that it inherits arbitrary values
from the outer execution.
Nor can you silently change the execution context and pretend that you
are still simulating the same C execution.
And there is something even more elementary.
Your trace never executes:
-a-a call simulateXXX
or:
-a-a call DDDD
It establishes NOTHING about whether DDDD can reach its return statement.
It merely shows that your outer HHHH returns immediately because its
initial test evaluates depth > 0.
SO ANSWER THE ACTUAL QUESTION:
What is the initial value of depth in your simulated process, and WHY?
If it is zero, your trace is inconsistent with the source code.
If it is positive, explain precisely how that state was established and which execution you are supposedly simulating.
STOP HIDING BEHIND THE WORD "SIMULATION".
A faithful simulator must preserve the semantics of the program it simulates.
Peter,
-a-a "That means that your code seems to crash the stack."
SEEMS?
You have the source code. You have the machine code. You have the emulator.--
SHOW THE FUCKING STACK OVERFLOW.
Your previous trace executes exactly 19 instructions.
It never calls DDDD.
It never calls simulateXXX.
It never performs a recursive call.
THERE IS NO STACK OVERFLOW IN THAT TRACE.
Now, if your simulator creates a fresh process with depth initialized to zero every time it encounters HHHH, you may indeed produce unbounded recursion.
BUT THAT IS NOT THE EXECUTION I DESCRIBED.
In my example, the nested HHHH invocation observes depth == 1 and
returns 0. Consequently, DDDD returns normally.
The crucial question is whether the simulated invocation shares the
existing program state or starts in a newly initialized state.
YOU MUST SPECIFY WHICH.
You cannot change the state semantics halfway through the argument and
then declare that my counterexample fails.
And you still haven't answered the simplest question of all:
WHY DOES YOUR PREVIOUS TRACE TAKE THE depth > 0 BRANCH AT THE VERY FIRST HHHH CALL?
If depth starts at zero, it should not.
If depth starts above zero, explain why.
If your emulator crashes the stack in some other execution, provide THAT trace, including the initial state and the sequence of nested calls.
Until then, "seems to crash the stack" is speculation, not a refutation.
Peter,
-a-a "That means that your code seems to crash the stack."
SEEMS?
You have the source code. You have the machine code. You have the emulator.
Peter,
-a-a "Even if your code does prove its point
-a-a-a that only would show that the dbush
-a-a-a words are incorrect."
EXACTLY!
On 11/11/2026 8:23 AM, Python wrote:
Peter,
-a-a "Even if your code does prove its point
-a-a-a that only would show that the dbush
-a-a-a words are incorrect."
EXACTLY!
So I add one word. DONE !!!
There does not exist any implementation of C function HHH
that [ONLY] simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Le 11/11/2026 |a 15:30, olcott a |-crit :
On 11/11/2026 8:23 AM, Python wrote:
Peter,
-a-a-a "Even if your code does prove its point
-a-a-a-a that only would show that the dbush
-a-a-a-a words are incorrect."
EXACTLY!
So I add one word. DONE !!!
There does not exist any implementation of C function HHH
that [ONLY] simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a "So I add one word. DONE !!!"
HAHAHAHA!
On 11/11/2026 8:31 AM, Python wrote:
Le 11/11/2026 |a 15:30, olcott a |-crit :
On 11/11/2026 8:23 AM, Python wrote:
Peter,
-a-a-a "Even if your code does prove its point
-a-a-a-a that only would show that the dbush
-a-a-a-a words are incorrect."
EXACTLY!
So I add one word. DONE !!!
There does not exist any implementation of C function HHH
that [ONLY] simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a "So I add one word. DONE !!!"
HAHAHAHA!
If I don't cut out the inessentials I will be
dead long before I get my work fully validated
by human experts.
99% of my reviewer begin with the axioms that I
must be wrong and spent 99% of the concentration
in the attempt to find an error.
If these same humans would spend 100% of these time
carefully focusing on understanding the details of
my proof and these same humans have the mandatory
prerequisite knowledge It would take less than two
hours to totally validate my current proof with each
human expert.
The mandatory prerequisite knowledge is an expert
in C, high intelligence to understand complex
reasoning.
No knowledge of the halting problem is required.
If there is knowledge of the halting problem then
this must be accompanied with deep knowledge of
theoretical foundations of computation.
Le 11/11/2026 |a 15:46, olcott a |-crit :
On 11/11/2026 8:31 AM, Python wrote:
Le 11/11/2026 |a 15:30, olcott a |-crit :
On 11/11/2026 8:23 AM, Python wrote:
Peter,
-a-a-a "Even if your code does prove its point
-a-a-a-a that only would show that the dbush
-a-a-a-a words are incorrect."
EXACTLY!
So I add one word. DONE !!!
There does not exist any implementation of C function HHH
that [ONLY] simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
-a-a-a "So I add one word. DONE !!!"
HAHAHAHA!
If I don't cut out the inessentials I will be
dead long before I get my work fully validated
by human experts.
99% of my reviewer begin with the axioms that I
must be wrong and spent 99% of the concentration
in the attempt to find an error.
If these same humans would spend 100% of these time
carefully focusing on understanding the details of
my proof and these same humans have the mandatory
prerequisite knowledge It would take less than two
hours to totally validate my current proof with each
human expert.
The mandatory prerequisite knowledge is an expert
in C, high intelligence to understand complex
reasoning.
No knowledge of the halting problem is required.
If there is knowledge of the halting problem then
this must be accompanied with deep knowledge of
theoretical foundations of computation.
Peter,
Your requirements for reviewing your "proof" are becoming RIDICULOUSLY PEDANTIC.
Apparently, a qualified reviewer must:
- Be an expert in C.
- Possess sufficiently high intelligence.
- Understand the foundations of computation, but preferably not know too much about the Halting Problem.
- Concentrate exclusively on understanding your proof rather than
looking for errors.
- Validate everything in less than two hours.
FOR FUCK'S SAKE!--
A mathematical proof is not validated by finding someone sufficiently intelligent to AGREE WITH YOU.
It is validated by surviving rigorous scrutiny.
LOOKING FOR ERRORS IS PRECISELY WHAT A COMPETENT REVIEWER IS SUPPOSED TO
DO.
And when someone produces a counterexample, the appropriate response is
not:
-a-a "I don't care about your code."
or:
-a-a "So I add one word. DONE !!!"
You have spent days arguing over the wording of a single sentence, repeatedly changing its meaning, while refusing to address the technical objections.
You don't need more intelligent reviewers, Peter.
You need a precise statement, a valid proof, and the willingness to
examine counterexamples.
And no, adding "ONLY" is not a substitute for any of those.
Your previous proposition said:
-a-a "any implementation of C function HHH
-a-a-a that simulates C function DD"
Your new proposition says:
-a-a "any implementation of C function HHH
-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
Peter,
-a-a "Very terribly bad paraphrase."
Fine. Let me correct it.
You require reviewers who know the Halting Problem to ALSO have expert knowledge of the foundations of computation.
Fair enough.
NOW WHAT?
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of infinite recursion, but then it also wouldn't be the HHH which he claims to be a potential halt decider, so the argument falls apart.
Andr|-
Peter,
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct?
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing for
non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of infinite
recursion, but then it also wouldn't be the HHH which he claims to be
a potential halt decider, so the argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing
for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of infinite
recursion, but then it also wouldn't be the HHH which he claims to be
a potential halt decider, so the argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in your
new formulation. I'd offered my interpretation, but you neither confirm
nor deny it. How does repeating three things verbatim from your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that by actually providing the requested clarification. What does the word ONLY achieve in your new formulation?
Andr|-
Le 11/11/2026 a 14:23, olcott a ocrit :
On 11/11/2026 6:23 AM, Python wrote:
Le 11/11/2026 a 05:41, olcott a ocrit :
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 a 17:16, Python a ocrit :int HHHH(ptr P);
Le 10/11/2026 a 17:15, olcott a ocrit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 a 15:57, olcott a ocrit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 a 02:02, olcott a ocrit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 a 19:18, olcott a ocrit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:
Peter,
aaa "simulated D would never stop running
aaaa unless [simulation is] aborted"
becomes:
aaa "simulated D would never stop running
aaaa while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted] >>>>>>>>>>>>> aaaa is translated into
aaaa "simulated D would never stop running while being simulated" >>>>>>>>>>>>> aaaa [would never stop running]
aaaa is translated into
aaaa never halts
aaaa [simulated D would never stop running unless aborted] >>>>>>>>>>>>> aaaa becomes
aaaa "simulated D would never halt while being simulated" >>>>>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
aaaa > WHILE THE SIMULATION CONTINUES,
aaaa > DD DOES NOT REACH ITS RETURN.
aaaa >
aaaa [REACH ITS RETURN]
aaaa is translated into
aaaa HALT
aaaa On 11/2/2026 8:50 AM, Python wrote:
aaaa > WHILE THE SIMULATION CONTINUES,
aaaa > DD DOES NOT REACH ITS RETURN.
aaaa >
aaaa is translated into
aaaa WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>
(1) "simulated D would never halt while being simulated" >>>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
Peter,
FINALLY, you have written two statements that can be compared directly.
aaa (1) Simulated D would never halt
aaaaaaa while being simulated.
aaa (2) WHILE THE SIMULATION CONTINUES,
aaaaaaa DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
aaa "Show how they can express different propositions."
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches >>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>> steps.
Peter,
aaa "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement".
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a much stronger proposition that
I NEVER agreed to.
Your alleged agreement now contains:
aaa "There does not exist ANY implementation..."
aaa "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES.
You have transformed that into a universal claim about EVERY possible implementation of HHH
and EVERY finite number of steps.
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>>>>>
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>>
You reject it because it does not satisfy the stronger proposition whose derivation is
precisely what is being challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition instead of dishonestly
pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation
of HHH returns 0.
According to the operational semantics of C, DD then executes:
aaa int Halt_Status = HHH(DD);
aaa if (Halt_Status)
aaaaaaa HERE: goto HERE;
aaa return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify PRECISELY what additional
constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict that quantification whenever
someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH invoked by the simulated DD
must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like pseudocode: >>>>>
aaa int HHH(ptr P)
aaa {
aaaaaaa static int depth = 0;
aaaaaaa if (depth > 0)
aaaaaaaaaaa return 0;
aaaaaaa depth++;
aaaaaaa simulate(P);
aaaaaaa depth--;
aaaaaaa return 1;
aaa }
Here, simulate(P) faithfully simulates the execution of P, including the code of HHH itself and
its access to the simulated state.
The execution proceeds as follows:
int DDDD()
{
aa int Halt_Status = HHHH(DDDD);
aa if (Halt_Status)
aaaa HERE: goto HERE;
aa return Halt_Status;
}
int simulateXXX(ptr P)
{
aa P();
aa return 1;
}
int HHHH(ptr P)
{
aa static int depth = 0;
aa if (depth > 0)
aaaa return 0;
aa depth++;
aa simulateXXX(P);
aa depth--;
aa return 1;
}
int main()
{
aa Output("Input_Halts = ", HHHH(DDDD));
aa return 0;
}
I can give the the machine code trace.
It is quite verbose. The simulated DDDD
never reaches its own simulated return
and HHHH returns the correct halt status.
dbush could see that the meaning of these words made them true:
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
(1) This seems dead obvious to me.
(2) The above words
*There does not exist any implementation of C function HHH*
that dbush composed are better than my own best words.
Peter,
THANK YOU.
You have just provided a concrete C program that REFUTES YOUR OWN CLAIM. >>>
Let's execute YOUR code.
Initially:
aaa depth = 0
The outer HHHH(DDDD) executes:
aaa depth++;
Now:
aaa depth = 1
Then:
aaa simulateXXX(DDDD);
which executes:
aaa DDDD();
Inside DDDD:
aaa Halt_Status = HHHH(DDDD);
This nested invocation executes:
aaa if (depth > 0)
aaaaaaa return 0;
Since depth == 1, HHHH returns 0.
Back inside DDDD:
aaa Halt_Status == 0
Therefore:
aaa if (Halt_Status)
aaaaaaa HERE: goto HERE;
does NOT enter the loop.
And the very next statement is:
aaa return Halt_Status;
DDDD RETURNS ZERO.
The outer HHHH then decrements depth and returns 1.
So YOUR OWN PROGRAM establishes:
aaa DDDD reaches its return statement.
aaa HHHH(DDDD) returns 1.
aaa Both executions terminate.
aaa The returned halt status is correct.
And yet you write:
aaa "The simulated DDDD never reaches
aaaa its own simulated return"
WHAT THE FUCK ARE YOU TALKING ABOUT?
Your simulateXXX calls DDDD directly rather than interpreting its machine instructions. But the
actual C execution is perfectly clear.
YES, PLEASE PROVIDE THE MACHINE CODE TRACE.
In particular, show us where DDDD supposedly fails to execute its return instruction.
Because according to the C code YOU JUST POSTED, it MUST reach that return. >>>
You have managed to construct a counterexample to your own universal claim, POST IT YOURSELF, and
then declare that it proves the exact opposite.
That is quite an achievement.
_HHHH()
[000021f6] 55aaaaaaaaaaaa push ebp
[000021f7] 8becaaaaaaaaaa mov ebp,esp
[000021f9] 833d0000000000 cmp dword [00000000],+00
[00002200] 7e04aaaaaaaaaa jng 00002206
[00002202] 33c0aaaaaaaaaa xor eax,eax
[00002204] eb2daaaaaaaaaa jmp 00002233
[00002206] a100000000aaaa mov eax,[00000000]
[0000220b] 83c001aaaaaaaa add eax,+01
[0000220e] a300000000aaaa mov [00000000],eax
[00002213] 8b4d08aaaaaaaa mov ecx,[ebp+08]
[00002216] 51aaaaaaaaaaaa push ecx
[00002217] e84a000000aaaa call 00002266
[0000221c] 83c404aaaaaaaa add esp,+04
[0000221f] 8b1500000000aa mov edx,[00000000]
[00002225] 83ea01aaaaaaaa sub edx,+01
[00002228] 891500000000aa mov [00000000],edx
[0000222e] b801000000aaaa mov eax,00000001
[00002233] 5daaaaaaaaaaaa pop ebp
[00002234] c3aaaaaaaaaaaa ret
Size in bytes:(0063) [00002234]
_DDDD()
[00002236] 55aaaaaaaaaaaa push ebp
[00002237] 8becaaaaaaaaaa mov ebp,esp
[00002239] 51aaaaaaaaaaaa push ecx
[0000223a] 6836220000aaaa push 00002236
[0000223f] e8b2ffffffaaaa call 000021f6
[00002244] 83c404aaaaaaaa add esp,+04
[00002247] 8945fcaaaaaaaa mov [ebp-04],eax
[0000224a] 837dfc00aaaaaa cmp dword [ebp-04],+00
[0000224e] 7402aaaaaaaaaa jz 00002252
[00002250] ebfeaaaaaaaaaa jmp 00002250
[00002252] 8b45fcaaaaaaaa mov eax,[ebp-04]
[00002255] 8be5aaaaaaaaaa mov esp,ebp
[00002257] 5daaaaaaaaaaaa pop ebp
[00002258] c3aaaaaaaaaaaa ret
Size in bytes:(0035) [00002258]
_simulateXXX()
[00002266] 55aaaaaaaaaaaa push ebp
[00002267] 8becaaaaaaaaaa mov ebp,esp
[00002269] ff5508aaaaaaaa call dword [ebp+08]
[0000226c] b801000000aaaa mov eax,00000001
[00002271] 5daaaaaaaaaaaa pop ebp
[00002272] c3aaaaaaaaaaaa ret
Size in bytes:(0013) [00002272]
_main()
[00002276] 55aaaaaaaaaaaa push ebp
[00002277] 8becaaaaaaaaaa mov ebp,esp
[00002279] 6836220000aaaa push 00002236
[0000227e] e873ffffffaaaa call 000021f6
[00002283] 83c404aaaaaaaa add esp,+04
[00002286] 50aaaaaaaaaaaa push eax
[00002287] 6887070000aaaa push 00000787
[0000228c] e815e5ffffaaaa call 000007a6
[00002291] 83c408aaaaaaaa add esp,+08
[00002294] 33c0aaaaaaaaaa xor eax,eax
[00002296] 5daaaaaaaaaaaa pop ebp
[00002297] c3aaaaaaaaaaaa ret
Size in bytes:(0034) [00002297]
a machineaa stackaaaa stackaaaa machineaaaaaaa assembly
a addressaa addressaa dataaaaaa codeaaaaaaaaaa language
a ========a ========a ========a ============== =============
[00002276][001039d6][00000000] 55aaaaaaaaaaaa push ebp
[00002277][001039d6][00000000] 8becaaaaaaaaaa mov ebp,esp
[00002279][001039d2][00002236] 6836220000aaaa push 00002236
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa // call HHH(DDDD)
[0000227e][001039ce][00002283] e873ffffffaaaa call 000021f6
[000021f6][001039ca][001039d6] 55aaaaaaaaaaaa push ebp
[000021f7][001039ca][001039d6] 8becaaaaaaaaaa mov ebp,esp
[000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00
[00002200][001039ca][001039d6] 7e04aaaaaaaaaa jng 00002206
[00002202][001039ca][001039d6] 33c0aaaaaaaaaa xor eax,eax
[00002204][001039ca][001039d6] eb2daaaaaaaaaa jmp 00002233
[00002233][001039ce][00002283] 5daaaaaaaaaaaa pop ebp
[00002234][001039d2][00002236] c3aaaaaaaaaaaa ret
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa // end HHHH
[00002283][001039d6][00000000] 83c404aaaaaaaa add esp,+04
[00002286][001039d2][00000000] 50aaaaaaaaaaaa push eax
[00002287][001039ce][00000787] 6887070000aaaa push 00000787
[0000228c][001039ce][00000787] e815e5ffffaaaa call 000007a6
Input_Halts = 0
[00002291][001039d6][00000000] 83c408aaaaaaaa add esp,+08
[00002294][001039d6][00000000] 33c0aaaaaaaaaa xor eax,eax
[00002296][001039da][90909090] 5daaaaaaaaaaaa pop ebp
[00002297][001039de][90909090] c3aaaaaaaaaaaa ret
Number of Instructions Executed(19) == 0 Pages
Peter,
THANK YOU FOR THE MACHINE CODE TRACE.
It exposes the problem immediately.
Look at YOUR trace:
aa 000021f9a cmp dword [00000000],+00
aa 00002200a jng 00002206
aa 00002202a xor eax,eax
aa 00002204a jmp 00002233
The conditional jump is NOT taken.
Therefore, the condition:
aa depth > 0
is TRUE at the very beginning of the OUTER HHHH invocation.
BUT YOUR SOURCE CODE DECLARES:
aa static int depth = 0;
At the start of the program, depth MUST be zero.
Consequently, the correct execution must take the branch to 00002206, increment depth, and call
simulateXXX(DDDD).
On 11/11/2026 13:30, Python wrote:
Le 11/11/2026 |a 14:23, olcott a |-crit :
On 11/11/2026 6:23 AM, Python wrote:
Le 11/11/2026 |a 05:41, olcott a |-crit :
On 11/10/2026 10:17 AM, Python wrote:
Le 10/11/2026 |a 17:16, Python a |-crit :int HHHH(ptr P);
Le 10/11/2026 |a 17:15, olcott a |-crit :
On 11/10/2026 9:38 AM, Python wrote:
Le 10/11/2026 |a 15:57, olcott a |-crit :
On 11/10/2026 4:50 AM, Python wrote:
Le 10/11/2026 |a 02:02, olcott a |-crit :
On 11/9/2026 3:29 PM, Python wrote:
Le 09/11/2026 |a 19:18, olcott a |-crit :Show how they can express different propositions.
On 11/9/2026 9:40 AM, Python wrote:Peter,
Peter,
-a-a-a "simulated D would never stop running
-a-a-a-a unless [simulation is] aborted"
becomes:
-a-a-a "simulated D would never stop running
-a-a-a-a while being simulated"
FINE.
And now?
(1) [simulated D would never stop running unless aborted] >>>>>>>>>>>>>> -a-a-a-a is translated into
-a-a-a-a "simulated D would never stop running while being >>>>>>>>>>>>>> simulated"
-a-a-a-a [would never stop running]
-a-a-a-a is translated into
-a-a-a-a never halts
-a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>>>>> -a-a-a-a becomes
-a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>>>>
(2) On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a [REACH ITS RETURN]
-a-a-a-a is translated into
-a-a-a-a HALT
-a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
-a-a-a-a > WHILE THE SIMULATION CONTINUES,
-a-a-a-a > DD DOES NOT REACH ITS RETURN.
-a-a-a-a >
-a-a-a-a is translated into
-a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>>
(1) "simulated D would never halt while being simulated" >>>>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>
FINALLY, you have written two statements that can be >>>>>>>>>>>>> compared directly.
-a-a-a (1) Simulated D would never halt
-a-a-a-a-a-a-a while being simulated.
-a-a-a (2) WHILE THE SIMULATION CONTINUES,
-a-a-a-a-a-a-a DD DOES NOT HALT.
As English sentences, these CAN express the same proposition. >>>>>>>>>>>>>
Otherwise acknowledge that they cannot express
different propositions.
Peter,
-a-a-a "Show how they can express different propositions." >>>>>>>>>>>
I ALREADY FUCKING DID.
Consider a program D that halts after 1,000 steps.
Simulate D for 100 steps, then abort the simulation.
That does not meet either one
*This is the five way agreement* (Sunday November 1)
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches >>>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>>> steps.
Peter,
-a-a-a "That does not meet either one."
Of course it doesn't meet your alleged "five-way agreement". >>>>>>>>>
BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU
DISHONESTLY PRETEND IT IS. :-)
You have once again replaced what I ACTUALLY agreed to with a >>>>>>>>> much stronger proposition that I NEVER agreed to.
Your alleged agreement now contains:
-a-a-a "There does not exist ANY implementation..."
-a-a-a "... in ANY N finite number of steps."
WHERE THE FUCK DID I AGREE TO THAT?
I agreed that DD does not reach its return WHILE THE SIMULATION >>>>>>>>> CONTINUES.
You have transformed that into a universal claim about EVERY >>>>>>>>> possible implementation of HHH and EVERY finite number of steps. >>>>>>>>>
THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT >>>>>>>>> FOR DAYS.
And your counterexample objection is ridiculous.
I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>>>
You reject it because it does not satisfy the stronger
proposition whose derivation is precisely what is being
challenged.
CIRCULAR REASONING, AGAIN.
Your alleged five-way agreement is not a proof.
Your misrepresentation of my words is not a proof.
And repeating both for another five years won't produce one.
Do you agree with this?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
Peter,
NO.
And FINALLY, you are asking whether I agree with this proposition >>>>>>> instead of dishonestly pretending that I already agreed to it.
Your claim quantifies over ANY implementation of HHH.
Consider an implementation of HHH that correctly simulates DD,
but whose simulated invocation of HHH returns 0.
According to the operational semantics of C, DD then executes:
-a-a-a int Halt_Status = HHH(DD);
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
-a-a-a return Halt_Status;
HHH returns 0.
The conditional branch is not taken.
DD reaches its return.
END OF FUCKING STORY.
If you want to exclude such an implementation, you must specify >>>>>>> PRECISELY what additional constraints you impose on HHH.
And then prove your proposition under those constraints.
You cannot quantify over ANY implementation and silently restrict >>>>>>> that quantification whenever someone provides a counterexample.
So, once again:
NO, I DO NOT AGREE WITH YOUR PROPOSITION.
And I NEVER DID.
A technical clarification concerning my previous message.
You might object that the HHH executing the simulation and the HHH >>>>>> invoked by the simulated DD must be the SAME implementation.
FINE.
Consider the following implementation, expressed in C-like
pseudocode:
-a-a-a int HHH(ptr P)
-a-a-a {
-a-a-a-a-a-a-a static int depth = 0;
-a-a-a-a-a-a-a if (depth > 0)
-a-a-a-a-a-a-a-a-a-a-a return 0;
-a-a-a-a-a-a-a depth++;
-a-a-a-a-a-a-a simulate(P);
-a-a-a-a-a-a-a depth--;
-a-a-a-a-a-a-a return 1;
-a-a-a }
Here, simulate(P) faithfully simulates the execution of P,
including the code of HHH itself and its access to the simulated
state.
The execution proceeds as follows:
int DDDD()
{
-a-a int Halt_Status = HHHH(DDDD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}
int simulateXXX(ptr P)
{
-a-a P();
-a-a return 1;
}
int HHHH(ptr P)
{
-a-a static int depth = 0;
-a-a if (depth > 0)
-a-a-a-a return 0;
-a-a depth++;
-a-a simulateXXX(P);
-a-a depth--;
-a-a return 1;
}
int main()
{
-a-a Output("Input_Halts = ", HHHH(DDDD));
-a-a return 0;
}
I can give the the machine code trace.
It is quite verbose. The simulated DDDD
never reaches its own simulated return
and HHHH returns the correct halt status.
dbush could see that the meaning of these words made them true:
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
(1) This seems dead obvious to me.
(2) The above words
*There does not exist any implementation of C function HHH*
that dbush composed are better than my own best words.
Peter,
THANK YOU.
You have just provided a concrete C program that REFUTES YOUR OWN
CLAIM.
Let's execute YOUR code.
Initially:
-a-a-a depth = 0
The outer HHHH(DDDD) executes:
-a-a-a depth++;
Now:
-a-a-a depth = 1
Then:
-a-a-a simulateXXX(DDDD);
which executes:
-a-a-a DDDD();
Inside DDDD:
-a-a-a Halt_Status = HHHH(DDDD);
This nested invocation executes:
-a-a-a if (depth > 0)
-a-a-a-a-a-a-a return 0;
Since depth == 1, HHHH returns 0.
Back inside DDDD:
-a-a-a Halt_Status == 0
Therefore:
-a-a-a if (Halt_Status)
-a-a-a-a-a-a-a HERE: goto HERE;
does NOT enter the loop.
And the very next statement is:
-a-a-a return Halt_Status;
DDDD RETURNS ZERO.
The outer HHHH then decrements depth and returns 1.
So YOUR OWN PROGRAM establishes:
-a-a-a DDDD reaches its return statement.
-a-a-a HHHH(DDDD) returns 1.
-a-a-a Both executions terminate.
-a-a-a The returned halt status is correct.
And yet you write:
-a-a-a "The simulated DDDD never reaches
-a-a-a-a its own simulated return"
WHAT THE FUCK ARE YOU TALKING ABOUT?
Your simulateXXX calls DDDD directly rather than interpreting its
machine instructions. But the actual C execution is perfectly clear.
YES, PLEASE PROVIDE THE MACHINE CODE TRACE.
In particular, show us where DDDD supposedly fails to execute its
return instruction.
Because according to the C code YOU JUST POSTED, it MUST reach that
return.
You have managed to construct a counterexample to your own universal
claim, POST IT YOURSELF, and then declare that it proves the exact
opposite.
That is quite an achievement.
_HHHH()
[000021f6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[000021f7] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[000021f9] 833d0000000000 cmp dword [00000000],+00
[00002200] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
[00002202] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002204] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
[00002206] a100000000-a-a-a-a mov eax,[00000000]
[0000220b] 83c001-a-a-a-a-a-a-a-a add eax,+01
[0000220e] a300000000-a-a-a-a mov [00000000],eax
[00002213] 8b4d08-a-a-a-a-a-a-a-a mov ecx,[ebp+08]
[00002216] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002217] e84a000000-a-a-a-a call 00002266
[0000221c] 83c404-a-a-a-a-a-a-a-a add esp,+04
[0000221f] 8b1500000000-a-a mov edx,[00000000]
[00002225] 83ea01-a-a-a-a-a-a-a-a sub edx,+01
[00002228] 891500000000-a-a mov [00000000],edx
[0000222e] b801000000-a-a-a-a mov eax,00000001
[00002233] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002234] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0063) [00002234]
_DDDD()
[00002236] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002237] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002239] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[0000223a] 6836220000-a-a-a-a push 00002236
[0000223f] e8b2ffffff-a-a-a-a call 000021f6
[00002244] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002247] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[0000224a] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000224e] 7402-a-a-a-a-a-a-a-a-a-a jz 00002252
[00002250] ebfe-a-a-a-a-a-a-a-a-a-a jmp 00002250
[00002252] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002255] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002257] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002258] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002258]
_simulateXXX()
[00002266] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002267] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002269] ff5508-a-a-a-a-a-a-a-a call dword [ebp+08]
[0000226c] b801000000-a-a-a-a mov eax,00000001
[00002271] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002272] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0013) [00002272]
_main()
[00002276] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002277] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002279] 6836220000-a-a-a-a push 00002236
[0000227e] e873ffffff-a-a-a-a call 000021f6
[00002283] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002286] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
[00002287] 6887070000-a-a-a-a push 00000787
[0000228c] e815e5ffff-a-a-a-a call 000007a6
[00002291] 83c408-a-a-a-a-a-a-a-a add esp,+08
[00002294] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002296] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002297] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0034) [00002297]
-a machine-a-a stack-a-a-a-a stack-a-a-a-a machine-a-a-a-a-a-a-a assembly >>> -a address-a-a address-a-a data-a-a-a-a-a code-a-a-a-a-a-a-a-a-a-a language >>> -a ========-a ========-a ========-a ============== =============
[00002276][001039d6][00000000] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002277][001039d6][00000000] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002279][001039d2][00002236] 6836220000-a-a-a-a push 00002236
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // call HHH(DDDD)
[0000227e][001039ce][00002283] e873ffffff-a-a-a-a call 000021f6
[000021f6][001039ca][001039d6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[000021f7][001039ca][001039d6] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00
[00002200][001039ca][001039d6] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
[00002202][001039ca][001039d6] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002204][001039ca][001039d6] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
[00002233][001039ce][00002283] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002234][001039d2][00002236] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // end HHHH
[00002283][001039d6][00000000] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002286][001039d2][00000000] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
[00002287][001039ce][00000787] 6887070000-a-a-a-a push 00000787
[0000228c][001039ce][00000787] e815e5ffff-a-a-a-a call 000007a6
Input_Halts = 0
[00002291][001039d6][00000000] 83c408-a-a-a-a-a-a-a-a add esp,+08
[00002294][001039d6][00000000] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
[00002296][001039da][90909090] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002297][001039de][90909090] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Number of Instructions Executed(19) == 0 Pages
Peter,
THANK YOU FOR THE MACHINE CODE TRACE.
It exposes the problem immediately.
Look at YOUR trace:
-a-a-a 000021f9-a cmp dword [00000000],+00
-a-a-a 00002200-a jng 00002206
-a-a-a 00002202-a xor eax,eax
-a-a-a 00002204-a jmp 00002233
The conditional jump is NOT taken.
Therefore, the condition:
-a-a-a depth > 0
is TRUE at the very beginning of the OUTER HHHH invocation.
BUT YOUR SOURCE CODE DECLARES:
-a-a-a static int depth = 0;
At the start of the program, depth MUST be zero.
Consequently, the correct execution must take the branch to 00002206,
increment depth, and call simulateXXX(DDDD).
Yeah, this is the problem in PO's x86utm that I mentioned in response to your previous counter-example code:-a it does not bother to support the
BSS segment.-a Because you have initialised depth to zero, the compiler assigns it to the BSS segment (which contains zeroed storage), but PO
never maps that to anything.-a Hence its assignment to virtual address 00000000 in the trace.-a I also mentioned the x86utm bug where PO only process relocations in the code segment, although that does not impact
your code here.-a Looks like PO didn't see my comments and rush to fix
his code!
If PO fixed x86utm it would behave as you've described.-a An alternative bypass would be for you to initialise depth to 1, so the compiler will
map it to the DATA segment rather than BSS.-a (x86utm handles the DATA segment.)-a Then in HHHH you could test "if (depth > 1)" instead of "if (depth > 0)".
Mike.
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being wrong
about something in regards to it, at least once???
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being wrong
about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being wrong
about something in regards to it, at least once???
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS!
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being wrong
about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing
for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of infinite
recursion, but then it also wouldn't be the HHH which he claims to
be a potential halt decider, so the argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in
your new formulation. I'd offered my interpretation, but you neither
confirm nor deny it. How does repeating three things verbatim from
your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that by
actually providing the requested clarification. What does the word
ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being wrong
about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the invariant that HHH not cut DD simulation's short after the recursion is demonstrated
HHH violates the invariant so it violates it's own proof that DD is recursive
sipser said that same thing polcott
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing
for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of infinite >>>>> recursion, but then it also wouldn't be the HHH which he claims to
be a potential halt decider, so the argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in
your new formulation. I'd offered my interpretation, but you neither
confirm nor deny it. How does repeating three things verbatim from
your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that by
actually providing the requested clarification. What does the word
ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit of
doing this -- people ask questions or for clarifications and you simply repost stuff we've all already read which doesn't actually answer
anything. If what you posted wasn't clear the first time, repeating it
isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the word 'ONLY' in your new wording accomplishes. I'd given my best guess as to
what you meant by this [still present in the above quoted text], but
your reply above leaves me none the wiser about whether I was on the
right track.
Andr|-
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing >>>>>> for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of infinite >>>>>> recursion, but then it also wouldn't be the HHH which he claims to >>>>>> be a potential halt decider, so the argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in
your new formulation. I'd offered my interpretation, but you neither
confirm nor deny it. How does repeating three things verbatim from
your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that by
actually providing the requested clarification. What does the word
ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit of
doing this -- people ask questions or for clarifications and you simply
repost stuff we've all already read which doesn't actually answer
anything. If what you posted wasn't clear the first time, repeating it
isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the word
'ONLY' in your new wording accomplishes. I'd given my best guess as to
what you meant by this [still present in the above quoted text], but
your reply above leaves me none the wiser about whether I was on the
right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to testing >>>>>> for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt
decider') then yes, HHH(DD) would be stuck in a pattern of
infinite recursion, but then it also wouldn't be the HHH which he >>>>>> claims to be a potential halt decider, so the argument falls apart. >>>>>>
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in
your new formulation. I'd offered my interpretation, but you neither
confirm nor deny it. How does repeating three things verbatim from
your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that by
actually providing the requested clarification. What does the word
ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit of
doing this -- people ask questions or for clarifications and you
simply repost stuff we've all already read which doesn't actually
answer anything. If what you posted wasn't clear the first time,
repeating it isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the word
'ONLY' in your new wording accomplishes. I'd given my best guess as to
what you meant by this [still present in the above quoted text], but
your reply above leaves me none the wiser about whether I was on the
right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to
testing for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt >>>>>>> decider') then yes, HHH(DD) would be stuck in a pattern of
infinite recursion, but then it also wouldn't be the HHH which he >>>>>>> claims to be a potential halt decider, so the argument falls apart. >>>>>>>
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in
your new formulation. I'd offered my interpretation, but you
neither confirm nor deny it. How does repeating three things
verbatim from your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that
by actually providing the requested clarification. What does the
word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit of
doing this -- people ask questions or for clarifications and you
simply repost stuff we've all already read which doesn't actually
answer anything. If what you posted wasn't clear the first time,
repeating it isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the
word 'ONLY' in your new wording accomplishes. I'd given my best guess
as to what you meant by this [still present in the above quoted
text], but your reply above leaves me none the wiser about whether I
was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be asking
for clarification.
Above I wrote that I thought by ONLY simulates DD you meant simulates as opposed to simulates with the possibility of aborting DD.
I'm asking for a simple confirmation or denial that this is what you meant.
Andr|-
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated.
HHH only actually demonstrates one step of
recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to
testing for non-halting patterns and subsequently aborting DD. >>>>>>>>
If HHH /were/ a pure simulator (as opposed to a 'simulating halt >>>>>>>> decider') then yes, HHH(DD) would be stuck in a pattern of
infinite recursion, but then it also wouldn't be the HHH which >>>>>>>> he claims to be a potential halt decider, so the argument falls >>>>>>>> apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in >>>>>> your new formulation. I'd offered my interpretation, but you
neither confirm nor deny it. How does repeating three things
verbatim from your previous posts offer any sort of clarification? >>>>>>
Communication is not your strong point. Maybe try working on that >>>>>> by actually providing the requested clarification. What does the
word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit of
doing this -- people ask questions or for clarifications and you
simply repost stuff we've all already read which doesn't actually
answer anything. If what you posted wasn't clear the first time,
repeating it isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the
word 'ONLY' in your new wording accomplishes. I'd given my best
guess as to what you meant by this [still present in the above
quoted text], but your reply above leaves me none the wiser about
whether I was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be asking
for clarification.
Above I wrote that I thought by ONLY simulates DD you meant simulates
as opposed to simulates with the possibility of aborting DD.
While being simulated
I'm asking for a simple confirmation or denial that this is what you
meant.
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
If the simulated DD stops being simulated then it
suddenly becomes a static text string.
Peter,
-a-a "If I was not correct then at least one person
-a-a-a could point to an actual error in the last 22 years."
FOR FUCK'S SAKE, PETER.
Just a few hours ago, you wrote:
-a-a "Even if your code does prove its point
-a-a-a that only would show that the dbush
-a-a-a words are incorrect."
Then you announced:
-a-a "So I add one word. DONE !!!"
YOU CHANGED YOUR CLAIM TO ESCAPE A COUNTEREXAMPLE.
And now you boast that nobody has found an error in 22 years?
More fundamentally, the absence of an error YOU ACCEPT is not evidence--
that your proof is correct.
Nor is the number of years you have defended it.
You claim to have reduced computable functions to their "simplest
possible essence".
Wonderful.
Then it should be particularly easy to provide:
1. A precise mathematical definition of "ONLY simulates".
2. A formal statement of your theorem.
3. A proof establishing that theorem from its hypotheses.
No complaints about reviewers.
No appeals to your 22 years of effort.
No more moving the goalposts.
JUST THE MATHEMATICS.
Le 12/11/2026 |a 05:52, olcott a |-crit :
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to
testing for non-halting patterns and subsequently aborting DD.
If HHH /were/ a pure simulator (as opposed to a 'simulating halt >>>>>>> decider') then yes, HHH(DD) would be stuck in a pattern of
infinite recursion, but then it also wouldn't be the HHH which he >>>>>>> claims to be a potential halt decider, so the argument falls apart. >>>>>>>
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation
All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY in
your new formulation. I'd offered my interpretation, but you
neither confirm nor deny it. How does repeating three things
verbatim from your previous posts offer any sort of clarification?
Communication is not your strong point. Maybe try working on that
by actually providing the requested clarification. What does the
word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit of
doing this -- people ask questions or for clarifications and you
simply repost stuff we've all already read which doesn't actually
answer anything. If what you posted wasn't clear the first time,
repeating it isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the
word 'ONLY' in your new wording accomplishes. I'd given my best guess
as to what you meant by this [still present in the above quoted
text], but your reply above leaves me none the wiser about whether I
was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Peter,
-a-a "It avoids the possible issue that Python raised."
WE KNOW WHY YOU ADDED "ONLY", PETER.
WE ARE ASKING WHAT IT MEANS.
Andr|- has asked you repeatedly.
I have asked you repeatedly.
You keep explaining your MOTIVATION instead of defining your TERM.
Let us consider Andr|-'s interpretation:
If "ONLY simulates" means that HHH faithfully executes DD's instructions without any additional mechanism for detecting nontermination or
aborting the simulation, then yes, a simulation of a nonterminating DD
will never reach DD's return statement.
SO WHAT?
That is simply what faithful simulation of a nonterminating computation means.--
It establishes absolutely nothing about the correctness of your alleged
halt decider.
Indeed, under that interpretation, HHH is no longer the halt decider you claim to have constructed.
On the other hand, if "ONLY simulates" permits detecting infinite
execution patterns and aborting the simulation, then you must explain precisely which additional operations are permitted and why your
detector is sound.
You cannot have it both ways.
And your excursion into Post canonical systems and semi-Thue systems
changes NOTHING.
Turing-equivalent models do not magically make nontermination decidable.
So answer Andr|-'s perfectly straightforward question:
WHAT EXACTLY DOES "ONLY" EXCLUDE?
Not WHY you added it.
WHAT IT MEANS.
-a-a "Are you going to keep pretending that the Professor
-a-a-a Sipser approved criteria has not been met?"
READ YOUR OWN QUOTATION.
-a-a "If simulating halt decider H correctly simulates its
-a-a-a input D until H CORRECTLY DETERMINES that its simulated D
-a-a-a would never stop running unless aborted then..."
CORRECTLY DETERMINES.
THOSE ARE THE KEY WORDS.
Observing recursive calls does not, by itself, establish infinite
recursion.
Aborting a simulation does not establish that the simulated program--
would never halt.
And repeatedly asserting that your detector is correct is NOT A PROOF OF
ITS CORRECTNESS.
Dart200 has explained the problem:
Your HHH observes a finite execution prefix and then aborts the simulation.
You claim that the execution WOULD HAVE continued forever.
THAT IS THE CLAIM YOU MUST PROVE.
You cannot use the hypothetical infinite continuation as evidence for
the correctness of the abort decision, and then use that decision as
proof of the infinite continuation.
THAT IS CIRCULAR REASONING.
Furthermore, your quotation is CONDITIONAL.
Even if Sipser agreed with every word of it, that would not establish
that your implementation satisfies its premise.
"If H correctly determines X" does not mean "Olcott's H correctly
determines X".
FOR FUCK'S SAKE, PETER.
You have spent years repeating the word "correctly" where a proof of correctness is required.
SHOW THAT YOUR FINITE OBSERVATION NECESSARILY IMPLIES NONTERMINATION.
Or stop pretending that quoting a conditional statement establishes its premise.
On 2026-11-12 10:11, polcott wrote:
On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to
testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>
If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern of >>>>>>>>> infinite recursion, but then it also wouldn't be the HHH which >>>>>>>>> he claims to be a potential halt decider, so the argument falls >>>>>>>>> apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation >>>>>>>> All Turing equivalent computations can be reduced to applying
finite string transformation rules to finite string inputs to
derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY >>>>>>> in your new formulation. I'd offered my interpretation, but you >>>>>>> neither confirm nor deny it. How does repeating three things
verbatim from your previous posts offer any sort of clarification? >>>>>>>
Communication is not your strong point. Maybe try working on that >>>>>>> by actually providing the requested clarification. What does the >>>>>>> word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit
of doing this -- people ask questions or for clarifications and you >>>>> simply repost stuff we've all already read which doesn't actually
answer anything. If what you posted wasn't clear the first time,
repeating it isn't going to provide any clarification.
You'd been asked to clarify what you thought the inclusion of the
word 'ONLY' in your new wording accomplishes. I'd given my best
guess as to what you meant by this [still present in the above
quoted text], but your reply above leaves me none the wiser about
whether I was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be asking
for clarification.
Above I wrote that I thought by ONLY simulates DD you meant simulates
as opposed to simulates with the possibility of aborting DD.
While being simulated
That doesn't clarify anything. It's not even a complete sentence. It certainly makes no mention of what you mean by ONLY.
I'm asking for a simple confirmation or denial that this is what you
meant.
Is the above really too much to ask?
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
You've already posted the above numerous times. Posting it yet one more
time isn't going to make it any clearer.
Andr|-
If the simulated DD stops being simulated then it
suddenly becomes a static text string.
On 11/12/2026 1:16 AM, dart200 wrote:^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT
correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial
recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not infinite.
the infinite recursion only occurs if HHH doesn't break the invariant
of letting the simulation run, but HHH does break that invariant, so
invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/12/26 9:40 AM, olcott wrote:
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not infinite.
the infinite recursion only occurs if HHH doesn't break the invariant
of letting the simulation run, but HHH does break that invariant, so
invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the decision
is _not_ valid if DD is then aborted EfOa
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not infinite.
the infinite recursion only occurs if HHH doesn't break the
invariant of letting the simulation run, but HHH does break that
invariant, so invalidating the induction requires to prove infinite
recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated.
HHH only actually demonstrates one step of
recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT
correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial
recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the shit
out of a threads stack... I made a manual recursion for AppleSoft BASIC
for fun while trying to port some of my algos to it:
https://pastebin.com/raw/Effeg8cK
100 REM ct_vfield_applesoft_basic
110-a-a-a-a HOME
120-a-a-a-a HGR: HCOLOR = 3: VTAB 22
130-a-a-a-a PRINT "ct_vfield_applesoft_basic"
140-a-a-a-a GOSUB 1000
150-a-a-a-a GOSUB 3000
160-a-a-a-a SP = 0
170-a-a-a-a RS(SP, 0) = 0
180-a-a-a-a RS(SP, 1) = -1
190-a-a-a-a RS(SP, 2) = 0
200-a-a-a-a RS(SP, 3) = 1
210-a-a-a-a RS(SP, 4) = 0
220-a-a-a-a GOSUB 8000
230-a-a-a-a V1(1) = 0: V1(2) = 0: V1(3) = 1: V1(4) = 128
240-a-a-a-a GOSUB 6000
245-a-a-a-a PRINT "Chris Thomasson's Koch Complete!"
250 END
1000 REM ct_init
1010-a-a-a-a PRINT "ct_init"
1020-a-a-a-a DIM A0(6)
1030-a-a-a-a DIM V0(4)
1040-a-a-a-a DIM V1(4)
1050-a-a-a-a DIM V2(4)
1060-a-a-a-a DIM V3(4)
1070-a-a-a-a DIM V4(4)
1080-a-a-a-a DIM V5(4)
1090-a-a-a-a RN = 3
1100-a-a-a-a DIM RS(RN, 16)
1110-a-a-a-a-a-a-a-a GOSUB 2000
1120 RETURN
2000 REM ct_init_plane
2010-a-a-a-a PRINT "ct_init_plane"
2020-a-a-a-a A0(1) = 279: REM m_plane.m_width
2030-a-a-a-a A0(2) = 191: REM m_plane.m_height
2040-a-a-a-a A0(3) = 0.0126106: REM m_plane.m_xstep
2050-a-a-a-a A0(4) = 0.0126316: REM m_plane.m_ystep
2060-a-a-a-a A0(5) = -1.75288: REM m_plane.m_axes.m_xmin
2070-a-a-a-a A0(6) = 1.2: REM m_plane.m_axes.m_ymax
2080 RETURN
3000 REM ct_display_plane
3010-a-a-a-a PRINT "ct_display_plane"
3020-a-a-a-a FOR I0 = 1 TO 6
3030-a-a-a-a-a-a-a-a PRINT "A0("; I0; ") = " A0(I0)
3040-a-a-a-a NEXT I0
3050 RETURN
4000 REM ct_project_point
4010-a-a-a-a REM PRINT "ct_project_point"
4020-a-a-a-a V0(3) = (V0(1) - A0(5)) / A0(3)
4030-a-a-a-a V0(4) = (A0(6) - V0(2)) / A0(4)
4040-a-a-a-a IF V0(3) < 0 THEN V0(3) = INT(V0(3) - .5)
4050-a-a-a-a IF V0(3) >= 0 THEN V0(3) = INT(V0(3) + .5)
4060-a-a-a-a IF V0(4) < 0 THEN V0(4) = INT(V0(4) - .5)
4070-a-a-a-a IF V0(4) >= 0 THEN V0(4) = INT(V0(4) + .5)
4080 RETURN
5000 REM ct_plot_point
5010-a-a-a-a REM PRINT "ct_plot_point"
5020-a-a-a-a GOSUB 4000
5030-a-a-a-a IF V0(3) > -1 AND V0(3) <= A0(1) AND V0(4) > -1 AND V0(4) <= A0(2) THEN HPLOT V0(3), V0(4)
5040 RETURN
6000 REM ct_plot_circle
6010-a-a-a-a PRINT "ct_plot_circle"
6020-a-a-a-a AB = 6.28318 / V1(4)
6030-a-a-a-a FOR I1 = 0 TO 6.28318 STEP AB
6040-a-a-a-a-a-a-a-a V0(1) = V1(1) + COS(I1) * V1(3)
6050-a-a-a-a-a-a-a-a V0(2) = V1(2) + SIN(I1) * V1(3)
6060-a-a-a-a-a-a-a-a GOSUB 5000
6070-a-a-a-a NEXT I1
6080 RETURN
7000 REM ct_plot_line
7010-a-a-a-a PRINT "ct_plot_line"
7020-a-a-a-a V0(1) = V5(1): V0(2) = V5(2)
7030-a-a-a-a GOSUB 4000
7040-a-a-a-a IF V0(3) < 0 THEN V0(3) = 0
7050-a-a-a-a IF V0(3) > A0(1) THEN V0(3) = A0(1)
7060-a-a-a-a IF V0(4) < 0 THEN V0(4) = 0
7070-a-a-a-a IF V0(4) > A0(2) THEN V0(4) = A0(2)
7080-a-a-a-a HPLOT V0(3), V0(4)
7090-a-a-a-a V0(1) = V5(3): V0(2) = V5(4)
7100-a-a-a-a GOSUB 4000
7110-a-a-a-a IF V0(3) < 0 THEN V0(3) = 0
7120-a-a-a-a IF V0(3) > A0(1) THEN V0(3) = A0(1)
7130-a-a-a-a IF V0(4) < 0 THEN V0(4) = 0
7140-a-a-a-a IF V0(4) > A0(2) THEN V0(4) = A0(2)
7150-a-a-a-a HPLOT TO V0(3), V0(4)
7160 RETURN
8000 REM ct_koch
8010-a-a-a-a IF RS(SP, 0) >= RN THEN RETURN
8020-a-a-a-a PRINT "ct_koch = "; RS(SP, 0); " "; RS(SP, 1); " "; RS(SP, 2); " "; RS(SP, 3); " "; RS(SP, 4)"
8030-a-a-a-a RS(SP, 5) = RS(SP, 3) - RS(SP, 1) : REM difx
8040-a-a-a-a RS(SP, 6) = RS(SP, 4) - RS(SP, 2) : REM dify
8050-a-a-a-a RS(SP, 7) = RS(SP, 1) + RS(SP, 5) / 2 : REM dify
8060-a-a-a-a RS(SP, 8) = RS(SP, 2) + RS(SP, 6) / 2 : REM dify
8070-a-a-a-a RS(SP, 9) = -RS(SP, 6) : REM perpx
8080-a-a-a-a RS(SP, 10) = RS(SP, 5) : REM perpy
8090-a-a-a-a RS(SP, 11) = RS(SP, 7) + RS(SP, 9) / 3 : REM tipx
8100-a-a-a-a RS(SP, 12) = RS(SP, 8) + RS(SP, 10) / 3 : REM tipy
8110-a-a-a-a RS(SP, 13) = RS(SP, 1) + RS(SP, 5) / 3 : REM k0x
8120-a-a-a-a RS(SP, 14) = RS(SP, 2) + RS(SP, 6) / 3 : REM k0y
8130-a-a-a-a RS(SP, 15) = RS(SP, 3) - RS(SP, 5) / 3 : REM k1x
8140-a-a-a-a RS(SP, 16) = RS(SP, 4) - RS(SP, 6) / 3 : REM k1y
8145-a-a-a-a IF RS(SP, 0) < RN - 1 GOTO 8230
8150-a-a-a-a V5(1) = RS(SP, 1): V5(2) = RS(SP, 2): V5(3) = RS(SP, 13): V5(4) = RS(SP, 14)
8160-a-a-a-a GOSUB 7000
8170-a-a-a-a V5(1) = RS(SP, 13): V5(2) = RS(SP, 14): V5(3) = RS(SP, 11): V5(4) = RS(SP, 12)
8180-a-a-a-a GOSUB 7000
8190-a-a-a-a V5(1) = RS(SP, 11): V5(2) = RS(SP, 12): V5(3) = RS(SP, 15): V5(4) = RS(SP, 16)
8200-a-a-a-a GOSUB 7000
8210-a-a-a-a V5(1) = RS(SP, 15): V5(2) = RS(SP, 16): V5(3) = RS(SP, 3): V5(4) = RS(SP, 4)
8220-a-a-a-a GOSUB 7000
8230-a-a-a-a REM line 0
8240-a-a-a-a SP = SP + 1
8250-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
8260-a-a-a-a RS(SP, 1) = RS(SP - 1, 1)
8270-a-a-a-a RS(SP, 2) = RS(SP - 1, 2)
8280-a-a-a-a RS(SP, 3) = RS(SP - 1, 13)
8290-a-a-a-a RS(SP, 4) = RS(SP - 1, 14)
8300-a-a-a-a GOSUB 8000
8310-a-a-a-a SP = SP - 1
8320-a-a-a-a REM line 1
8330-a-a-a-a SP = SP + 1
8340-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
8350-a-a-a-a RS(SP, 1) = RS(SP - 1, 13)
8360-a-a-a-a RS(SP, 2) = RS(SP - 1, 14)
8370-a-a-a-a RS(SP, 3) = RS(SP - 1, 11)
8380-a-a-a-a RS(SP, 4) = RS(SP - 1, 12)
8390-a-a-a-a GOSUB 8000
8400-a-a-a-a SP = SP - 1
8410-a-a-a-a REM line 2
8420-a-a-a-a SP = SP + 1
8430-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
8440-a-a-a-a RS(SP, 1) = RS(SP - 1, 11)
8450-a-a-a-a RS(SP, 2) = RS(SP - 1, 12)
8460-a-a-a-a RS(SP, 3) = RS(SP - 1, 15)
8470-a-a-a-a RS(SP, 4) = RS(SP - 1, 16)
8480-a-a-a-a GOSUB 8000
8490-a-a-a-a SP = SP - 1
8500-a-a-a-a REM line 3
8510-a-a-a-a SP = SP + 1
8520-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
8530-a-a-a-a RS(SP, 1) = RS(SP - 1, 15)
8540-a-a-a-a RS(SP, 2) = RS(SP - 1, 16)
8550-a-a-a-a RS(SP, 3) = RS(SP - 1, 3)
8560-a-a-a-a RS(SP, 4) = RS(SP - 1, 4)
8570-a-a-a-a GOSUB 8000
8580-a-a-a-a SP = SP - 1
8590 RETURN
HHH only actually demonstrates one step of recursion, not infinite.
the infinite recursion only occurs if HHH doesn't break the invariant
of letting the simulation run, but HHH does break that invariant, so
invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not infinite. >>>>> the infinite recursion only occurs if HHH doesn't break the
invariant of letting the simulation run, but HHH does break that
invariant, so invalidating the induction requires to prove infinite >>>>> recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the
shit out of a threads stack... I made a manual recursion for AppleSoft
BASIC for fun while trying to port some of my algos to it:
why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not
infinite. the infinite recursion only occurs if HHH doesn't break >>>>>> the invariant of letting the simulation run, but HHH does break
that invariant, so invalidating the induction requires to prove
infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once? ? ?
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on >>>> the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not infinite.
the infinite recursion only occurs if HHH doesn't break the invariant >>>> of letting the simulation run, but HHH does break that invariant, so
invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
^^^^^^^^^^^^^^^^^^^
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the decision
is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the
shit out of a threads stack... I made a manual recursion for
AppleSoft BASIC for fun while trying to port some of my algos to it:
why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
[...]
Well, basically to see how portable my algos really are. So far, I have
all of my fractals that use recursion, and even some of my n-ary vector fields! Let me get an older screenshot of it, I posted it in a BASIC
group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
Peter,
-a-a "I will only address one single point per reply."
EXCELLENT.
ONE POINT IT IS.
-a-a "There is something fundamentally incorrect
-a-a-a with the Halting Problem proofs."
WHAT, EXACTLY?
Identify ONE specific step in the standard diagonal proof that is mathematically invalid.--
Not something you dislike.
Not something you have redefined.
Not something you claim to have disproved after 22 years.
ONE INVALID INFERENCE.
The standard proof assumes a total, correct halting decider H and
constructs a program D that does the opposite of what H predicts about D itself.
If H predicts that D halts, D loops.
If H predicts that D does not halt, D halts.
Therefore no such total, correct H exists.
WHICH STEP IS WRONG?
You have spent 22 years claiming that something is fundamentally incorrect.
You should be able to identify the error in ONE SENTENCE.
And please spare us another lecture about Post canonical systems,
reviewer qualifications, or the meaning of "ONLY".
ONE POINT.
ONE ERROR.
WHERE IS IT?
Le 12/11/2026 |a 20:43, olcott a |-crit :
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once? ? ?
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not infinite. >>>>> the infinite recursion only occurs if HHH doesn't break the
invariant of letting the simulation run, but HHH does break that
invariant, so invalidating the induction requires to prove infinite >>>>> recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
Peter,
-a-a "That is not even what those English words mean."
For once, you have a point.
Your sentence does NOT say that aborting the simulation automatically invalidates the decision.
It says:
-a-a "If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a would never stop running unless aborted then..."
Fine.
A simulator MAY abort an execution after correctly establishing that it would otherwise run forever.
NOBODY NEEDS TO DISPUTE THAT.
But now comes the part you keep conveniently ignoring:
-a-a "H CORRECTLY DETERMINES"
HOW?
Your simulator observes a finite sequence of execution steps.--
It detects recursion.
It aborts.
And you declare that the computation would never have terminated.
WHERE IS THE PROOF OF THAT LAST STEP?
The fact that the simulation was faithful UP TO THE ABORT does not
establish that its prediction about the infinite future was correct.
Nor does the fact that Sipser may have accepted your conditional statement.
A conditional statement does not establish its own premise.
"If H correctly determines nontermination" is perfectly compatible with
the possibility that YOUR H does NOT correctly determine nontermination.
You wrote those words.
You say Sipser approved them.
VERY WELL.
NOW PROVE THAT YOUR PROGRAM SATISFIES THEM.
And please, Peter, don't answer by explaining the operational semantics
of C for the thousandth time.
WE AGREE ABOUT FAITHFUL SIMULATION.
THE QUESTION IS THE CORRECTNESS OF YOUR NONTERMINATION DECISION.
Peter,
-a-a "The behavior of H(D) is outside of the scope
-a-a-a of Turing computation when D calls H(D)"
NO, PETER.
THAT IS PRECISELY WHAT YOU HAVE TO PROVE.
A program calling another program which, in turn, calls the first--
program is perfectly expressible within Turing computation.
Recursion is computable.
Self-reference is computable.
Simulation is computable.
NONE OF THESE IS OUTSIDE THE TURING MODEL.
What is impossible is a TOTAL, CORRECT algorithm deciding whether EVERY arbitrary computation halts.
And the diagonal construction demonstrates exactly WHY.
You assume that H is such an algorithm.
You construct D using H.
You derive a contradiction.
Therefore YOUR ASSUMPTION WAS FALSE.
THAT IS HOW A PROOF BY CONTRADICTION WORKS.
You cannot escape the contradiction by declaring that the very case
exposing it is "outside the scope of Turing computation".
That would simply mean your alleged universal decider does not handle
every computable input.
WHICH IS EXACTLY WHAT THE HALTING THEOREM SAYS.
And your toaster analogy is ridiculous.
A toaster cannot inflate tires because it lacks the necessary physical mechanism.
A Turing machine can perfectly well represent and simulate recursive
program calls.
What it cannot do is compute a total, correct halting predicate for all programs.
YOU ARE CONFUSING EXPRESSIBILITY WITH DECIDABILITY.
After 22 years, THAT is your "bottom line"?
Peter,
-a-a "I already explained the details of this
-a-a-a to you too many times."
NO.
You have explained HOW your simulator detects recursion.
You have NOT established that the detected recursion can NEVER terminate.
THOSE ARE TWO DIFFERENT THINGS.--
-a-a "You have been in full rebuttal mode ever since."
OF COURSE I HAVE.
You claim to have found a fundamental error in one of the most
elementary theorems of computability theory.
WHAT DID YOU EXPECT?
Applause?
A standing ovation?
A reviewer who politely agrees without checking your reasoning?
FOR FUCK'S SAKE, PETER.
A proof is supposed to withstand rebuttal.
And your complaint about my attitude does not establish a single mathematical fact.
So here is the question, once again:
WHAT EXACTLY GUARANTEES THAT THE RECURSION DETECTED BY YOUR HHH CAN
NEVER TERMINATE?
Not that recursion has begun.
Not that your simulator has aborted it.
Not that you have explained your code a thousand times.
WHAT PROVES THAT IT WOULD CONTINUE FOREVER?
If you have already demonstrated this, reproduce the decisive argument.
ONE POINT.
ONE PROOF.
NO EXCUSES.
Peter,
-a-a "I have but you just don't care enough
-a-a-a to pay attention to the details."
Then identify the precise step in your proof establishing that H(D) is outside the scope of Turing computation.
Because your claim is fundamentally confused.--
A Turing machine can simulate another Turing machine.
That simulated machine can itself simulate another machine.
And the process can continue recursively.
THERE IS NOTHING NON-TURING-COMPUTABLE ABOUT THAT.
If the resulting computation never terminates, the Turing machine simply runs forever.
NONTERMINATION IS NOT THE SAME THING AS NONCOMPUTABILITY.
This is the distinction you keep missing.
The Halting Theorem does NOT say that the diagonal program cannot be constructed or executed.
It says that no total computable function can correctly decide the
halting behavior of EVERY program, including the diagonal one.
If H(D) fails to return, H is not total.
If H(D) returns an incorrect answer, H is not correct.
Either way, the hypothetical universal halting decider does not exist.
THAT IS THE THEOREM.
And declaring that the troublesome computation is "outside the scope of Turing computation" merely evades the contradiction by restricting the domain.
It does not refute anything.
So please stop telling me that I haven't paid attention.
I have identified a precise mathematical distinction.
YOU HAVE NOT ANSWERED IT.
Peter,
-a-a "Its a bunch of subtle steps."
No, Peter.
It's a bunch of delusional evasions and confusions. In other words : a
bunch of bullshit.
And after 22 years, you still cannot identify a single invalid inference
in the standard proof.
You keep claiming that the diagonal computation is outside the scope of Turing computation.
WHY?
Because of recursion?
Because of self-reference?--
Because your simulator aborts?
NONE OF THESE ESTABLISHES YOUR CLAIM.
You don't need to explain everything at once.
START WITH THE FIRST STEP.
State its premises.
State its conclusion.
Show how the conclusion follows.
Then proceed to the next step.
THAT IS HOW A MATHEMATICAL PROOF WORKS.
"There's a bunch of subtle steps" is not a proof.
It's an excuse for not providing one.
Peter,
-a-a "DD cannot even reach its own paradoxical code."
WRONG.
The "paradoxical code" is not some mysterious instruction that DD must
reach after an infinite number of recursive calls.
It is the conditional statement:
-a-a if (Halt_Status)
-a-a-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
And whether DD reaches that statement depends on whether HHH(DD) returns.
NOW PAY ATTENTION.
The standard Halting Theorem assumes that H is a TOTAL, CORRECT halting decider.
TOTAL MEANS IT RETURNS AN ANSWER.
Therefore, under that assumption, DD DOES reach its conditional statement.
And then:--
If H says DD halts, DD loops.
If H says DD does not halt, DD returns.
CONTRADICTION.
If instead H never returns because it gets trapped in recursive
simulation, then H IS NOT TOTAL.
WHICH ALSO DISQUALIFIES IT AS A UNIVERSAL HALTING DECIDER.
Either way, the theorem stands.
Your alleged discovery that DD cannot reach its conditional statement
merely describes what happens when you replace the hypothetical total decider with a particular implementation that fails to return.
YOU HAVE NOT FOUND AN ERROR IN THE PROOF.
YOU HAVE DROPPED ONE OF ITS HYPOTHESES.
And after 22 years, you still confuse the consequences of an assumption
with the behavior of your own program.
On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
On 2026-11-12 10:11, polcott wrote:
On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>
If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern >>>>>>>>>> of infinite recursion, but then it also wouldn't be the HHH >>>>>>>>>> which he claims to be a potential halt decider, so the
argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation >>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>> finite string transformation rules to finite string inputs to >>>>>>>>> derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY >>>>>>>> in your new formulation. I'd offered my interpretation, but you >>>>>>>> neither confirm nor deny it. How does repeating three things
verbatim from your previous posts offer any sort of clarification? >>>>>>>>
Communication is not your strong point. Maybe try working on
that by actually providing the requested clarification. What
does the word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit >>>>>> of doing this -- people ask questions or for clarifications and
you simply repost stuff we've all already read which doesn't
actually answer anything. If what you posted wasn't clear the
first time, repeating it isn't going to provide any clarification. >>>>>>
You'd been asked to clarify what you thought the inclusion of the >>>>>> word 'ONLY' in your new wording accomplishes. I'd given my best
guess as to what you meant by this [still present in the above
quoted text], but your reply above leaves me none the wiser about >>>>>> whether I was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be
asking for clarification.
Above I wrote that I thought by ONLY simulates DD you meant
simulates as opposed to simulates with the possibility of aborting DD. >>>>
While being simulated
That doesn't clarify anything. It's not even a complete sentence. It
certainly makes no mention of what you mean by ONLY.
I'm asking for a simple confirmation or denial that this is what you
meant.
Is the above really too much to ask?
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
-aThere does not exist any implementation of C function
-aHHH that ONLY simulates C function DD according to the
-aoperational semantics of C such that the simulated C
-afunction DD reaches its own simulated return statement
-ain any N finite number of steps
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
On 2026-11-12 11:52, olcott wrote:
On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
On 2026-11-12 10:11, polcott wrote:
On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>>
If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern >>>>>>>>>>> of infinite recursion, but then it also wouldn't be the HHH >>>>>>>>>>> which he claims to be a potential halt decider, so the
argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>> 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation >>>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>>> finite string transformation rules to finite string inputs to >>>>>>>>>> derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite string inputs is outside of the
domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word ONLY >>>>>>>>> in your new formulation. I'd offered my interpretation, but you >>>>>>>>> neither confirm nor deny it. How does repeating three things >>>>>>>>> verbatim from your previous posts offer any sort of clarification? >>>>>>>>>
Communication is not your strong point. Maybe try working on >>>>>>>>> that by actually providing the requested clarification. What >>>>>>>>> does the word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification
of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a habit >>>>>>> of doing this -- people ask questions or for clarifications and >>>>>>> you simply repost stuff we've all already read which doesn't
actually answer anything. If what you posted wasn't clear the
first time, repeating it isn't going to provide any clarification. >>>>>>>
You'd been asked to clarify what you thought the inclusion of the >>>>>>> word 'ONLY' in your new wording accomplishes. I'd given my best >>>>>>> guess as to what you meant by this [still present in the above
quoted text], but your reply above leaves me none the wiser about >>>>>>> whether I was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be
asking for clarification.
Above I wrote that I thought by ONLY simulates DD you meant
simulates as opposed to simulates with the possibility of aborting DD. >>>>>
While being simulated
That doesn't clarify anything. It's not even a complete sentence. It
certainly makes no mention of what you mean by ONLY.
I'm asking for a simple confirmation or denial that this is what
you meant.
Is the above really too much to ask?
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
-a-aThere does not exist any implementation of C function
-a-aHHH that ONLY simulates C function DD according to the
-a-aoperational semantics of C such that the simulated C
-a-afunction DD reaches its own simulated return statement
-a-ain any N finite number of steps
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
It doesn't matter how many times you repeat that last bit, it still
doesn't answer my question.
You changed the wording of your claim to include the word ONLY, but it
was unclear what the intent was.
When you say HHH ONLY simulates DD..
you're presumably excluding some other case such as the case where HHH
does something in addition to simulating DD, or simulates something in addition to DD. I'd interpreted it to mean that 'HHH ONLY simulates DD
and does not abort it'. I'd asked if my interpretation was on the right track. That's a simply yes/no question. I've already ready your above passage many times and it does not provide answers to this question.
So can you kindly simply answer with a yes or a no. If you want to
include additional explanation that's fine, but please include a yes or
a no.
Andr|-
Peter,
-a-a "when H applies the most relevant finite string
-a-a-a transformation / inference steps to its static
-a-a-a finite string D, then this input D cannot reach
-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
It assumes that H is a TOTAL, CORRECT COMPUTABLE DECIDER.--
HOW H WORKS IS IRRELEVANT.
It may simulate instructions.
It may analyze source code.
It may apply finite string rewriting rules.
It may use whatever computable inference procedure you like.
THE DIAGONAL ARGUMENT STILL APPLIES.
Suppose your finite string transformations correctly determine whether
every arbitrary program halts.
Then they constitute a halting decision algorithm.
Call it H.
Construct D to do the opposite of H's prediction about D.
And the contradiction follows.
If your transformations cannot produce a correct answer for this D, then they are NOT a universal halting decider.
THAT IS EXACTLY WHAT THE THEOREM PREDICTS.
-a-a "The way that the HP gets around all that
-a-a-a is they simply make sure to totally ignore
-a-a-a the limited categories of finite string
-a-a-a transformations..."
NONSENSE.
The theorem does not ignore those transformations.
IT INCLUDES THEM.
Every effective finite string rewriting procedure is subject to the same computability limits.
You cannot escape diagonalization by changing the implementation
language of H.
So here is ONE precise question:
Do your finite string transformation rules constitute a TOTAL, CORRECT algorithm for deciding whether ANY arbitrary program halts?
YES OR NO?
If YES, diagonalization applies to YOUR algorithm.
If NO, you have not contradicted the Halting Theorem.
And if you refuse to answer, stop pretending that the theorem somehow overlooked your favorite implementation technique.
Peter,
-a-a "Then you simply did not pay close enough
-a-a-a attention to the attempted rebuttal by Python."
NO, PETER.
ANDR|e IS PAYING ATTENTION.
YOU ARE NOT.
Andr|- has understood perfectly well WHY you added "ONLY".
You wanted to exclude my counterexample.--
WE GET IT.
But he is asking WHAT THE WORD EXCLUDES.
THAT IS A DIFFERENT QUESTION.
He even offered you a precise interpretation:
-a-a "HHH ONLY simulates DD and does not abort it."
And asked you to confirm or deny it.
YES OR NO.
Instead, you repeat:
-a-a "while DD is being simulated by HHH"
EIGHT TIMES!
FOR FUCK'S SAKE!
Repeating a sentence eight times does not define an undefined term.
And accusing someone of not paying attention does not answer their
question.
Andr|- has demonstrated considerable patience in trying to extract a
simple clarification from you.
You, meanwhile, have demonstrated an extraordinary ability to avoid
giving one.
So here is your opportunity.
Does "ONLY simulates" exclude aborting the simulation?
YES OR NO?
If you cannot answer even THAT, perhaps the problem is not that your reviewers lack intelligence or attention.
Perhaps the problem is that YOU DON'T KNOW WHAT YOUR OWN CLAIM MEANS.
On 11/12/26 12:49 PM, olcott wrote:
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short
after the initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not
infinite. the infinite recursion only occurs if HHH doesn't break >>>>>>> the invariant of letting the simulation run, but HHH does break >>>>>>> that invariant, so invalidating the induction requires to prove >>>>>>> infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>> -a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
and what does HHH ultimately do to the simulation of DD?
On 11/12/26 1:53 PM, dart200 wrote:
On 11/12/26 12:49 PM, olcott wrote:
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>>> invariant that HHH not cut DD simulation's short after the >>>>>>>>>> recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short >>>>>>>> after the initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not
infinite. the infinite recursion only occurs if HHH doesn't
break the invariant of letting the simulation run, but HHH does >>>>>>>> break that invariant, so invalidating the induction requires to >>>>>>>> prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>>> -a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
and what does HHH ultimately do to the simulation of DD?
polcott u didn't answer this...
On 11/12/2026 6:49 PM, dart200 wrote:
On 11/12/26 1:53 PM, dart200 wrote:
On 11/12/26 12:49 PM, olcott wrote:
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>> words to not conform to their false assumptions.
I can very much better show that these assumptions >>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>> the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on >>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>> the recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>> after the initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not
infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>> break the invariant of letting the simulation run, but HHH does >>>>>>>>> break that invariant, so invalidating the induction requires to >>>>>>>>> prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>>>> -a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the
decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
and what does HHH ultimately do to the simulation of DD?
polcott u didn't answer this...
Makes bologna sandwiches?
Peter,
-a-a "strcmp() is limited to those operations
-a-a-a that compare strings."
WRONG ANALOGY.
strcmp() is specified by WHAT IT COMPUTES, not by some arbitrary
restriction on HOW it must compute it.
An implementation may compare bytes sequentially, use word-sized
operations, vector instructions, or any other technique preserving the specified result.
NOW APPLY THE SAME PRINCIPLE TO HALTING DECIDERS.
A halting decider is specified by WHAT IT COMPUTES:
-a-a H(P, x) = 1 if P(x) halts
-a-a H(P, x) = 0 otherwise
It is NOT defined by HOW it obtains that answer.
-a-a "Halt deciders are limited to those
-a-a-a operations that can see behavior."
WHAT THE FUCK DOES "SEE BEHAVIOR" MEAN?
Peter,
-a-a "A halt decider must be able to correctly determine
-a-a-a the exact sequence of steps that an input finite
-a-a-a string specifies."
NO, PETER.
THAT IS NOT THE DEFINITION OF A HALTING DECIDER.
A halting decider must determine WHETHER a computation terminates.
NOT its exact sequence of execution steps.
For example, consider:
-a-a int f(void)
-a-a {
-a-a-a-a-a-a while (1) {}
-a-a }
We can prove that this function never terminates WITHOUT enumerating its infinite execution trace.
Likewise, we can prove that many terminating programs terminate without computing their complete execution traces.
You are confusing TWO DIFFERENT PROBLEMS:
1. Determining whether a computation terminates.
2. Determining its exact execution trace.
THEY ARE NOT THE SAME PROBLEM.
Peter,
-a-a "We must determine its exact execution up
-a-a-a to the point where we can determine whether
-a-a-a or not it terminates."
NO.
You have merely moved the goalposts.
First you required the exact sequence of execution steps.
Now you require it only "up to the point" where termination can be determined.
But that point can be reached WITHOUT EXECUTING OR SIMULATING A SINGLE
STEP.
Consider:
-a-a int f(unsigned n)
-a-a {
-a-a-a-a-a-a while (n > 0)
-a-a-a-a-a-a-a-a-a-a --n;
-a-a-a-a-a-a return 0;
-a-a }
We can prove that f terminates for every possible value of n simply
because n is a nonnegative integer that strictly decreases on each iteration.
NO EXECUTION TRACE IS REQUIRED.
NO SIMULATION IS REQUIRED.
NO ENUMERATION OF STEPS IS REQUIRED.
And for:
-a-a void g(void)
-a-a {
-a-a-a-a-a-a for (;;) {}
-a-a }
We can prove nontermination directly from the program structure.
Again, without reconstructing an infinite execution trace.
Your claim is not a theorem of computability.
It is an arbitrary restriction you keep trying to impose on the
definition of a halting decider.
So ONE question:
WHY must a halting decider reconstruct any execution steps when a mathematical proof already establishes the answer?
Peter,
-a-a "I certainly did not mean all infinite of them."
Nobody said you did.
The point is that determining termination does NOT require
reconstructing an execution trace, finite or infinite.
And now you bring up AProVE.
EXCELLENT EXAMPLE.
AProVE uses mathematical techniques to prove termination or
nontermination for classes of programs.
It does NOT need to simulate every execution step to establish its conclusions.
-a-a "Does it automatically know the answer
-a-a-a for any arbitrary input?"
OF COURSE NOT.
AND THAT IS PRECISELY THE POINT.
AProVE is not a universal halting decider.
For some inputs, it proves termination.
For others, it proves nontermination.
For still others, it cannot establish either result.
THAT IS ENTIRELY CONSISTENT WITH THE HALTING THEOREM.
You seem to believe that because no termination analyzer can solve every possible case, all termination analyzers must be restricted to reconstructing execution traces.
THAT DOES NOT FOLLOW.
And the fact that AProVE cannot decide every arbitrary case does not establish your claim that diagonal computations lie outside Turing computation.--
It establishes nothing of the sort.
So let's return to the ONE question you keep avoiding:
WHERE IS THE REQUIREMENT THAT A HALTING DECIDER MUST RECONSTRUCT
EXECUTION STEPS, RATHER THAN USE ANY COMPUTABLE MATHEMATICAL ANALYSIS?
A definition, Peter.
Not another example of an analyzer that cannot solve the undecidable.
On 11/12/26 4:51 PM, olcott wrote:
On 11/12/2026 6:49 PM, dart200 wrote:
On 11/12/26 1:53 PM, dart200 wrote:
On 11/12/26 12:49 PM, olcott wrote:
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>>> words to not conform to their false assumptions. >>>>>>>>>>>>>>>
I can very much better show that these assumptions >>>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>>> being wrong about something in regards to it, at least >>>>>>>>>>>>>> once???
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>>> the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on >>>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>>> the recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>>> after the initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not >>>>>>>>>> infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>>> break the invariant of letting the simulation run, but HHH >>>>>>>>>> does break that invariant, so invalidating the induction
requires to prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>> -a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the >>>>>>>> decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
and what does HHH ultimately do to the simulation of DD?
polcott u didn't answer this...
Makes bologna sandwiches?
ur claiming that HHH makes bologna sandwiches with the simulation of DD?
are you just a fking troll bro?
On 11/12/26 5:03 PM, dart200 wrote:
On 11/12/26 4:51 PM, olcott wrote:
On 11/12/2026 6:49 PM, dart200 wrote:
On 11/12/26 1:53 PM, dart200 wrote:
On 11/12/26 12:49 PM, olcott wrote:
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>>>> words to not conform to their false assumptions. >>>>>>>>>>>>>>>>
I can very much better show that these assumptions >>>>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>>>> being wrong about something in regards to it, at least >>>>>>>>>>>>>>> once???
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>>>> the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according >>>>>>>>>>>>>> to the operational semantics of the C programming
language specifies recursive simulation does seems >>>>>>>>>>>>>> to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on >>>>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>>>> the recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>>>> after the initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not >>>>>>>>>>> infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>>>> break the invariant of letting the simulation run, but HHH >>>>>>>>>>> does break that invariant, so invalidating the induction >>>>>>>>>>> requires to prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>> 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>>> -a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the >>>>>>>>> decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
and what does HHH ultimately do to the simulation of DD?
polcott u didn't answer this...
Makes bologna sandwiches?
ur claiming that HHH makes bologna sandwiches with the simulation of DD?
are you just a fking troll bro?
seriously bro after over 2 decades ur reduced to this level of trolling???
everyone knows DD halts
everyone knows HHH violates the invariant that sipser directly pointed out
ur not fooling anyone but urself dud
On 11/12/2026 6:30 PM, Andr|- G. Isaak wrote:
On 2026-11-12 11:52, olcott wrote:
On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
On 2026-11-12 10:11, polcott wrote:
On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>>>
If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern >>>>>>>>>>>> of infinite recursion, but then it also wouldn't be the HHH >>>>>>>>>>>> which he claims to be a potential halt decider, so the >>>>>>>>>>>> argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation >>>>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>>>> finite string transformation rules to finite string inputs to >>>>>>>>>>> derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string >>>>>>>>>>> transformations to finite string inputs is outside of the >>>>>>>>>>> domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word >>>>>>>>>> ONLY in your new formulation. I'd offered my interpretation, >>>>>>>>>> but you neither confirm nor deny it. How does repeating three >>>>>>>>>> things verbatim from your previous posts offer any sort of >>>>>>>>>> clarification?
Communication is not your strong point. Maybe try working on >>>>>>>>>> that by actually providing the requested clarification. What >>>>>>>>>> does the word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification >>>>>>>>> of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a
habit of doing this -- people ask questions or for
clarifications and you simply repost stuff we've all already
read which doesn't actually answer anything. If what you posted >>>>>>>> wasn't clear the first time, repeating it isn't going to provide >>>>>>>> any clarification.
You'd been asked to clarify what you thought the inclusion of >>>>>>>> the word 'ONLY' in your new wording accomplishes. I'd given my >>>>>>>> best guess as to what you meant by this [still present in the >>>>>>>> above quoted text], but your reply above leaves me none the
wiser about whether I was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be
asking for clarification.
Above I wrote that I thought by ONLY simulates DD you meant
simulates as opposed to simulates with the possibility of aborting >>>>>> DD.
While being simulated
That doesn't clarify anything. It's not even a complete sentence. It
certainly makes no mention of what you mean by ONLY.
I'm asking for a simple confirmation or denial that this is what
you meant.
Is the above really too much to ask?
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
-a-aThere does not exist any implementation of C function
-a-aHHH that ONLY simulates C function DD according to the
-a-aoperational semantics of C such that the simulated C
-a-afunction DD reaches its own simulated return statement
-a-ain any N finite number of steps
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
It doesn't matter how many times you repeat that last bit, it still
doesn't answer my question.
You changed the wording of your claim to include the word ONLY, but it
was unclear what the intent was.
Then you simply did not pay close enough attention
to the attempted rebuttal by Python.
-aWhen you say HHH ONLY simulates DD.. you're presumably excluding some
other case such as the case where HHH does something in addition to
simulating DD, or simulates something in addition to DD. I'd
interpreted it to mean that 'HHH ONLY simulates DD and does not abort
it'. I'd asked if my interpretation was on the right track. That's a
simply yes/no question. I've already ready your above passage many
times and it does not provide answers to this question.
So can you kindly simply answer with a yes or a no. If you want to
include additional explanation that's fine, but please include a yes
or a no.
Andr|-
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
Halt deciders are limited to those operations
that can see behavior.
On 11/12/2026 6:38 PM, Python wrote:
Peter,
-a-a-a "Then you simply did not pay close enough
-a-a-a-a attention to the attempted rebuttal by Python."
NO, PETER.
ANDR|e IS PAYING ATTENTION.
YOU ARE NOT.
Andr|- has understood perfectly well WHY you added "ONLY".
Then he was dishonest for asking why.
On 2026-11-12 17:35, olcott wrote:
On 11/12/2026 6:30 PM, Andr|- G. Isaak wrote:
On 2026-11-12 11:52, olcott wrote:
On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
On 2026-11-12 10:11, polcott wrote:
On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
On 2026-11-11 21:52, olcott wrote:
On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
On 2026-11-11 10:23, olcott wrote:
On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
On 2026-11-11 09:29, olcott wrote:
On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
On 2026-11-11 07:23, Python wrote:
Your previous proposition said:
-a-a-a "any implementation of C function HHH
-a-a-a-a that simulates C function DD"
Your new proposition says:
-a-a-a "any implementation of C function HHH
-a-a-a-a that ONLY simulates C function DD"
YOU HAVE ADDED "ONLY".
What exactly does "ONLY simulates" mean?
I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>>>>
If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a >>>>>>>>>>>>> pattern of infinite recursion, but then it also wouldn't be >>>>>>>>>>>>> the HHH which he claims to be a potential halt decider, so >>>>>>>>>>>>> the argument falls apart.
Andr|-
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the >>>>>>>>>>>> operational semantics of C such that the simulated C
function DD reaches its own simulated return statement >>>>>>>>>>>> in any N finite number of steps.
We can either map these words to
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>> 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>>>>> -a-a-a-a would never stop running unless aborted then
Or map them to
Computation defined
A simplified Paraphrase of Emil Post definition of computation >>>>>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>>>>> finite string transformation rules to finite string inputs to >>>>>>>>>>>> derive any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string >>>>>>>>>>>> transformations to finite string inputs is outside of the >>>>>>>>>>>> domain of ChurchrCoTuring computable functions.
He'd asked for you to clarify the significance of the word >>>>>>>>>>> ONLY in your new formulation. I'd offered my interpretation, >>>>>>>>>>> but you neither confirm nor deny it. How does repeating three >>>>>>>>>>> things verbatim from your previous posts offer any sort of >>>>>>>>>>> clarification?
Communication is not your strong point. Maybe try working on >>>>>>>>>>> that by actually providing the requested clarification. What >>>>>>>>>>> does the word ONLY achieve in your new formulation?
Andr|-
Because I spent 22 years of primary research from
first principles I had to toss out everything that
anyone thought that they knew about computation
and start from scratch.
This initially required me to correct the definitions
of standard terms-of-the-art with my own adaptations.
This caused most people to simply believe that I was
not getting the meaning of those terms correctly.
Now my reconstruction of the foundations of computation
is complete I can prove my point in terms of a simplification >>>>>>>>>> of Post Canonical Systems string rewriting system (SRS),
historically called a semi-Thue systems.
Any computation that cannot be reduced to applying
finite string transformations to finite string inputs
is out of the scope of Turing Equivalent computation
in the same way that filling your tires with air is
outside of the scope of your toaster.
None of the above addresses anything in my post. You have a >>>>>>>>> habit of doing this -- people ask questions or for
clarifications and you simply repost stuff we've all already >>>>>>>>> read which doesn't actually answer anything. If what you posted >>>>>>>>> wasn't clear the first time, repeating it isn't going to
provide any clarification.
You'd been asked to clarify what you thought the inclusion of >>>>>>>>> the word 'ONLY' in your new wording accomplishes. I'd given my >>>>>>>>> best guess as to what you meant by this [still present in the >>>>>>>>> above quoted text], but your reply above leaves me none the >>>>>>>>> wiser about whether I was on the right track.
Andr|-
It avoids the possible issue that Python raised.
Wasn't that as obvious as a pie in the face?
Now you're just being an ass. If it were obvious I wouldn't be
asking for clarification.
Above I wrote that I thought by ONLY simulates DD you meant
simulates as opposed to simulates with the possibility of
aborting DD.
While being simulated
That doesn't clarify anything. It's not even a complete sentence.
It certainly makes no mention of what you mean by ONLY.
I'm asking for a simple confirmation or denial that this is what >>>>>>> you meant.
Is the above really too much to ask?
There does not exist any implementation of C function
HHH that ONLY simulates C function DD according to the
operational semantics of C such that the simulated C
function DD reaches its own simulated return statement
in any N finite number of steps.
-a-aThere does not exist any implementation of C function
-a-aHHH that ONLY simulates C function DD according to the
-a-aoperational semantics of C such that the simulated C
-a-afunction DD reaches its own simulated return statement
-a-ain any N finite number of steps
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
while DD is being simulated by HHH.
It doesn't matter how many times you repeat that last bit, it still
doesn't answer my question.
You changed the wording of your claim to include the word ONLY, but
it was unclear what the intent was.
Then you simply did not pay close enough attention
to the attempted rebuttal by Python.
So you're not going to give me a simple (possibly qualified) answer to
my yes/no question?
I understand that you were trying to exclude Python's counterexample.
What I don't understand is exactly how your ONLY achieves just this or
exactly what ELSE it excludes. That's the big problem with ad hoc
exclusions -- you often end up excluding things that you shouldn't have
or things that you really didn't intend to.
In another post you claimed that you hoped you would soon be ready for rigorous peer review. What you're undergoing in comp.theory is not peer review; it is simply discussion. If you were to ever submit to peer
review you'd be expected to provide straight answers to questions, even
if you don't like those questions or don't understand why they are being asked. The sorts of snide retorts you've been providing on this
newsgroup would pretty much guarantee that your hypothetical paper would simply end up in the dustbin.
Andr|-
-aWhen you say HHH ONLY simulates DD.. you're presumably excluding
some other case such as the case where HHH does something in addition
to simulating DD, or simulates something in addition to DD. I'd
interpreted it to mean that 'HHH ONLY simulates DD and does not abort
it'. I'd asked if my interpretation was on the right track. That's a
simply yes/no question. I've already ready your above passage many
times and it does not provide answers to this question.
So can you kindly simply answer with a yes or a no. If you want to
include additional explanation that's fine, but please include a yes
or a no.
Andr|-
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive operations
that compare strings (The standard libraries do; the language does not).
So exactly which operations is it supposed to use? And if you claim that strcmp() is restricted to rely on strcmp() then you're caught in an infinitely recursive trap.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no restrictions
on which sorts of operations a halt decider can make use of, provided it ultimately returns the correct answer.
Andr|-
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive operations
that compare strings (The standard libraries do; the language does
not). So exactly which operations is it supposed to use? And if you
claim that strcmp() is restricted to rely on strcmp() then you're
caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make use
of, provided it ultimately returns the correct answer.
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive
operations that compare strings (The standard libraries do; the
language does not). So exactly which operations is it supposed to
use? And if you claim that strcmp() is restricted to rely on strcmp()
then you're caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated string- comparison operators. Nor does it have any tic-tac-toe specific
operators. We define functions in terms of their ultimate results; not
in terms of the intermediate operations they utilize. A tic-tac-toe
program might well use string-comparison operations internally. Strcmp() might potentially use any operations it feels like internally (including ones used by tic-tac-toe) provided it's ultimate output is consistent
with the function it is defined to perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make use
of, provided it ultimately returns the correct answer.
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question 'does
this input halt'. What operations it actually uses to accomplishes this
are entirely irrelevant. You gave the example of AProVE. This program
does not make use of operations which 'see' behaviour (whatever you
might mean by that), nor does it emulate code, nor does it produce a
trace up to the point where it can determine where something halts. It
is judged not by these criteria but rather by whether it actually
answers the questions which it claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string transformations, but
I don't recall you ever specifically mentioning a specific finite string transformation. This is just a buzz word you've picked up. If you really think you can solve halting via finite string transformations then presumably you can identify all the transformations involved (using, for example, GREP syntax).
Andr|-
On 11/12/2026 8:40 PM, dart200 wrote:
On 11/12/26 5:03 PM, dart200 wrote:
On 11/12/26 4:51 PM, olcott wrote:
On 11/12/2026 6:49 PM, dart200 wrote:
On 11/12/26 1:53 PM, dart200 wrote:
On 11/12/26 12:49 PM, olcott wrote:
On 11/12/2026 2:26 PM, dart200 wrote:
On 11/12/26 11:43 AM, olcott wrote:
On 11/12/2026 1:07 PM, dart200 wrote:
On 11/12/26 9:40 AM, olcott wrote:That is not even what those English words mean.
On 11/12/2026 1:16 AM, dart200 wrote:-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ^^^^^^^^^^^^^^^^^^^
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person >>>>>>>>>>>>>>>>> could point to an actual error in the last 22 years. >>>>>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>>>>> words to not conform to their false assumptions. >>>>>>>>>>>>>>>>>
Then a reviewer having an honest dialogue >>>>>>>>>>>>>>>>>>> that pays complete attention and makes no >>>>>>>>>>>>>>>>>>> attempt to change the subject can confirm >>>>>>>>>>>>>>>>>>> that I am correct very quickly.
Peter, have you considered the possibility that you >>>>>>>>>>>>>>>>>> are NOT correct?
I can very much better show that these assumptions >>>>>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this >>>>>>>>>>>>>>>> without being wrong about something in regards to it, at >>>>>>>>>>>>>>>> least once???
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>>>>> the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according >>>>>>>>>>>>>>> to the operational semantics of the C programming >>>>>>>>>>>>>>> language specifies recursive simulation does seems >>>>>>>>>>>>>>> to indicate that most people here are dishonest. >>>>>>>>>>>>>>>
the recursive simulation is purely a hypothetical based on >>>>>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>>>>> the recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>>>>> based on the invariant that HHH not cut DD simulation's >>>>>>>>>>>> short after the initial recursion is demonstrated.
Yes that is correct.
HHH only actually demonstrates one step of recursion, not >>>>>>>>>>>> infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>>>>> break the invariant of letting the simulation run, but HHH >>>>>>>>>>>> does break that invariant, so invalidating the induction >>>>>>>>>>>> requires to prove infinite recursion
sipser said that same thing polcott
Well that is good. You paid enough attention to
not contradict yourself.
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its >>>>>>>>>>> -a-a-a-a input D until H correctly determines that its simulated D >>>>>>>>>>> -a-a-a-a would never stop running unless aborted then
Are you going to keep pretending that the Professor
Sipser approved criteria has not been met?
no u don't meet sipser's criteria, he explicitly specifies the >>>>>>>>>> decision is _not_ valid if DD is then aborted EfOa
I wrote those words and he approved them.
ok so what does "unless aborted then" mean polcott?
All non-halting behavior such as an infinite
loop will continue to run unless aborted.
and what does HHH ultimately do to the simulation of DD?
polcott u didn't answer this...
Makes bologna sandwiches?
ur claiming that HHH makes bologna sandwiches with the simulation of DD? >>>
are you just a fking troll bro?
seriously bro after over 2 decades ur reduced to this level of
trolling???
everyone knows DD halts
everyone knows HHH violates the invariant that sipser directly pointed
out
You can't even pay attention to the meaning of words.
ur not fooling anyone but urself dud
On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive
operations that compare strings (The standard libraries do; the
language does not). So exactly which operations is it supposed to
use? And if you claim that strcmp() is restricted to rely on
strcmp() then you're caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated
string- comparison operators. Nor does it have any tic-tac-toe
specific operators. We define functions in terms of their ultimate
results; not in terms of the intermediate operations they utilize. A
tic-tac-toe program might well use string-comparison operations
internally. Strcmp() might potentially use any operations it feels
like internally (including ones used by tic-tac-toe) provided it's
ultimate output is consistent with the function it is defined to perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make
use of, provided it ultimately returns the correct answer.
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question
'does this input halt'. What operations it actually uses to
accomplishes this are entirely irrelevant. You gave the example of
AProVE. This program does not make use of operations which 'see'
behaviour (whatever you might mean by that), nor does it emulate code,
nor does it produce a trace up to the point where it can determine
where something halts. It is judged not by these criteria but rather
by whether it actually answers the questions which it claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string transformations,
but I don't recall you ever specifically mentioning a specific finite
string transformation. This is just a buzz word you've picked up. If
you really think you can solve halting via finite string
transformations then presumably you can identify all the
transformations involved (using, for example, GREP syntax).
Andr|-
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
I specify the inherent requirement that deciders
must apply finite string transformations that are
relevant to the decision criteria. This provides
a deeper understanding of the nature of deciders.
On 2026-11-12 21:25, olcott wrote:
On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or >>>>>>> simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive
operations that compare strings (The standard libraries do; the
language does not). So exactly which operations is it supposed to
use? And if you claim that strcmp() is restricted to rely on
strcmp() then you're caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated
string- comparison operators. Nor does it have any tic-tac-toe
specific operators. We define functions in terms of their ultimate
results; not in terms of the intermediate operations they utilize. A
tic-tac-toe program might well use string-comparison operations
internally. Strcmp() might potentially use any operations it feels
like internally (including ones used by tic-tac-toe) provided it's
ultimate output is consistent with the function it is defined to
perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make
use of, provided it ultimately returns the correct answer.
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question
'does this input halt'. What operations it actually uses to
accomplishes this are entirely irrelevant. You gave the example of
AProVE. This program does not make use of operations which 'see'
behaviour (whatever you might mean by that), nor does it emulate
code, nor does it produce a trace up to the point where it can
determine where something halts. It is judged not by these criteria
but rather by whether it actually answers the questions which it
claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string transformations,
but I don't recall you ever specifically mentioning a specific finite
string transformation. This is just a buzz word you've picked up. If
you really think you can solve halting via finite string
transformations then presumably you can identify all the
transformations involved (using, for example, GREP syntax).
Andr|-
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
I specify the inherent requirement that deciders
must apply finite string transformations that are
relevant to the decision criteria. This provides
a deeper understanding of the nature of deciders.
You've given a few non-controversial definitions which don't mention any actual finite string transformation rules.
So give me an example of such as finite string transformation rule
relevant to deciding a particular language (For example, the language
which describes all halting machines). Specify an *actual* rule. Don't
just talk in terms of vague generalities. Again, GREP syntax would be appropriate for your example.
If you can't specify an actual rule it becomes apparent you're just
throwing random terminology around without any actual understanding.
Andr|-
On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
On 2026-11-12 21:25, olcott wrote:
On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or >>>>>>>> simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive
operations that compare strings (The standard libraries do; the
language does not). So exactly which operations is it supposed to >>>>>> use? And if you claim that strcmp() is restricted to rely on
strcmp() then you're caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated
string- comparison operators. Nor does it have any tic-tac-toe
specific operators. We define functions in terms of their ultimate
results; not in terms of the intermediate operations they utilize. A
tic-tac-toe program might well use string-comparison operations
internally. Strcmp() might potentially use any operations it feels
like internally (including ones used by tic-tac-toe) provided it's
ultimate output is consistent with the function it is defined to
perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make >>>>>> use of, provided it ultimately returns the correct answer.
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question
'does this input halt'. What operations it actually uses to
accomplishes this are entirely irrelevant. You gave the example of
AProVE. This program does not make use of operations which 'see'
behaviour (whatever you might mean by that), nor does it emulate
code, nor does it produce a trace up to the point where it can
determine where something halts. It is judged not by these criteria
but rather by whether it actually answers the questions which it
claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string transformations,
but I don't recall you ever specifically mentioning a specific
finite string transformation. This is just a buzz word you've picked
up. If you really think you can solve halting via finite string
transformations then presumably you can identify all the
transformations involved (using, for example, GREP syntax).
Andr|-
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
I specify the inherent requirement that deciders
must apply finite string transformations that are
relevant to the decision criteria. This provides
a deeper understanding of the nature of deciders.
You've given a few non-controversial definitions which don't mention
any actual finite string transformation rules.
So give me an example of such as finite string transformation rule
relevant to deciding a particular language (For example, the language
which describes all halting machines). Specify an *actual* rule. Don't
just talk in terms of vague generalities. Again, GREP syntax would be
appropriate for your example.
I have done this for four years now.
What is the category of finite string transformation
that HHH could apply to the C source code of DD?
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT
correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial
recursion is demonstrated. HHH only actually demonstrates one step of
recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH
does break that invariant, so invalidating the induction requires to
prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 2026-11-12 21:45, olcott wrote:
On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
On 2026-11-12 21:25, olcott wrote:
On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing >>>>>>>>> or simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive
operations that compare strings (The standard libraries do; the >>>>>>> language does not). So exactly which operations is it supposed to >>>>>>> use? And if you claim that strcmp() is restricted to rely on
strcmp() then you're caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated
string- comparison operators. Nor does it have any tic-tac-toe
specific operators. We define functions in terms of their ultimate
results; not in terms of the intermediate operations they utilize.
A tic-tac-toe program might well use string-comparison operations
internally. Strcmp() might potentially use any operations it feels
like internally (including ones used by tic-tac-toe) provided it's
ultimate output is consistent with the function it is defined to
perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make >>>>>>> use of, provided it ultimately returns the correct answer.
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question
'does this input halt'. What operations it actually uses to
accomplishes this are entirely irrelevant. You gave the example of
AProVE. This program does not make use of operations which 'see'
behaviour (whatever you might mean by that), nor does it emulate
code, nor does it produce a trace up to the point where it can
determine where something halts. It is judged not by these criteria >>>>> but rather by whether it actually answers the questions which it
claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string
transformations, but I don't recall you ever specifically
mentioning a specific finite string transformation. This is just a
buzz word you've picked up. If you really think you can solve
halting via finite string transformations then presumably you can
identify all the transformations involved (using, for example, GREP >>>>> syntax).
Andr|-
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
I specify the inherent requirement that deciders
must apply finite string transformations that are
relevant to the decision criteria. This provides
a deeper understanding of the nature of deciders.
You've given a few non-controversial definitions which don't mention
any actual finite string transformation rules.
So give me an example of such as finite string transformation rule
relevant to deciding a particular language (For example, the language
which describes all halting machines). Specify an *actual* rule.
Don't just talk in terms of vague generalities. Again, GREP syntax
would be appropriate for your example.
I have done this for four years now.
What is the category of finite string transformation
that HHH could apply to the C source code of DD?
That's a question. And a rather poorly-posed one at that. I asked for an *example* of a finite string transformation rule.
What exactly is the 'category' of a finite string transformation? That question doesn't even make sense.
An actual rule would take the form of
String A -> String B
Explain exactly what A and B are here. GREP/Regex would be an
appropriate syntax for specifying this. Vague handwaving wouldn't be.
Andr|-
On 11/12/2026 10:55 PM, Andr|- G. Isaak wrote:
On 2026-11-12 21:45, olcott wrote:
On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
On 2026-11-12 21:25, olcott wrote:
On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing >>>>>>>>>> or simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive
operations that compare strings (The standard libraries do; the >>>>>>>> language does not). So exactly which operations is it supposed >>>>>>>> to use? And if you claim that strcmp() is restricted to rely on >>>>>>>> strcmp() then you're caught in an infinitely recursive trap.
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated
string- comparison operators. Nor does it have any tic-tac-toe
specific operators. We define functions in terms of their ultimate >>>>>> results; not in terms of the intermediate operations they utilize. >>>>>> A tic-tac-toe program might well use string-comparison operations >>>>>> internally. Strcmp() might potentially use any operations it feels >>>>>> like internally (including ones used by tic-tac-toe) provided it's >>>>>> ultimate output is consistent with the function it is defined to
perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can
make use of, provided it ultimately returns the correct answer. >>>>>>>>
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question >>>>>> 'does this input halt'. What operations it actually uses to
accomplishes this are entirely irrelevant. You gave the example of >>>>>> AProVE. This program does not make use of operations which 'see'
behaviour (whatever you might mean by that), nor does it emulate
code, nor does it produce a trace up to the point where it can
determine where something halts. It is judged not by these
criteria but rather by whether it actually answers the questions
which it claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string
transformations, but I don't recall you ever specifically
mentioning a specific finite string transformation. This is just a >>>>>> buzz word you've picked up. If you really think you can solve
halting via finite string transformations then presumably you can >>>>>> identify all the transformations involved (using, for example,
GREP syntax).
Andr|-
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
I specify the inherent requirement that deciders
must apply finite string transformations that are
relevant to the decision criteria. This provides
a deeper understanding of the nature of deciders.
You've given a few non-controversial definitions which don't mention
any actual finite string transformation rules.
So give me an example of such as finite string transformation rule
relevant to deciding a particular language (For example, the
language which describes all halting machines). Specify an *actual*
rule. Don't just talk in terms of vague generalities. Again, GREP
syntax would be appropriate for your example.
I have done this for four years now.
What is the category of finite string transformation
that HHH could apply to the C source code of DD?
That's a question. And a rather poorly-posed one at that. I asked for
an *example* of a finite string transformation rule.
What exactly is the 'category' of a finite string transformation? That
question doesn't even make sense.
An actual rule would take the form of
String A -> String B
Explain exactly what A and B are here. GREP/Regex would be an
appropriate syntax for specifying this. Vague handwaving wouldn't be.
Andr|-
What category of a finite string transformation
rule does strcmp() to derive 0 or non-zero?
Peter,
"Every termination analyzer must always somehow
determine the sequence of steps required to
determine whether an input finite string specifies
behavior that reaches a final state or not."
YOU ARE CONFUSING TWO ENTIRELY DIFFERENT SEQUENCES OF STEPS.
1. The steps performed by the ANALYZER.
2. The steps performed by the PROGRAM BEING ANALYZED.
Of course, a computable analyzer performs computational steps.
THAT DOES NOT MEAN IT MUST RECONSTRUCT THE EXECUTION STEPS OF ITS INPUT PROGRAM.
Consider again:
int f(unsigned n)
{
while (n > 0)
--n;
return 0;
}
A termination analyzer can establish that f terminates for every
unsigned n by finding a ranking function: n decreases strictly on each iteration and is bounded below by zero.
The analyzer manipulates mathematical properties of the program.
IT DOES NOT NEED TO SIMULATE ITS EXECUTION.
"For Turing computable functions this must always
be consistent with D simulated by H."
If "consistent" means that H's answer must agree with D's actual
termination behavior, OF COURSE.
That is called CORRECTNESS.
But if you mean that H must obtain its answer by simulating D, NO.
THAT IS NOT A REQUIREMENT OF COMPUTABILITY THEORY.
You have simply replaced the definition of a halting decider with your
own restricted implementation model.
And then you complain that the standard theorem does not respect your restriction.H1(D) derives the exact same steps as int main() { D(); }
OF COURSE IT DOESN'T.
THE RESTRICTION IS YOUR INVENTION.
One question, Peter:
DO YOU UNDERSTAND THAT AN ANALYZER'S COMPUTATION STEPS ARE NOT THE SAME THING AS THE EXECUTION STEPS OF THE PROGRAM IT ANALYZES?
YES OR NO?
On 2026-11-12 22:04, olcott wrote:
On 11/12/2026 10:55 PM, Andr|- G. Isaak wrote:
On 2026-11-12 21:45, olcott wrote:
On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
On 2026-11-12 21:25, olcott wrote:
On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
On 2026-11-12 20:45, olcott wrote:
On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach >>>>>>>>>>> -a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing >>>>>>>>>>> or simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive >>>>>>>>> operations that compare strings (The standard libraries do; the >>>>>>>>> language does not). So exactly which operations is it supposed >>>>>>>>> to use? And if you claim that strcmp() is restricted to rely on >>>>>>>>> strcmp() then you're caught in an infinitely recursive trap. >>>>>>>>>
It must somehow compare strings no version of
playing tic-tac-toe will fulfill the requirements.
You're entirely missing the point. C doesn't have any dedicated >>>>>>> string- comparison operators. Nor does it have any tic-tac-toe
specific operators. We define functions in terms of their
ultimate results; not in terms of the intermediate operations
they utilize. A tic-tac-toe program might well use string-
comparison operations internally. Strcmp() might potentially use >>>>>>> any operations it feels like internally (including ones used by >>>>>>> tic-tac-toe) provided it's ultimate output is consistent with the >>>>>>> function it is defined to perform.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no >>>>>>>>> restrictions on which sorts of operations a halt decider can >>>>>>>>> make use of, provided it ultimately returns the correct answer. >>>>>>>>>
There actually are restrictions the same as there
are restrictions for strcmp() no version of
playing tic-tac-toe will fulfill the requirements.
No one claimed otherwise. A halt decider must answer the question >>>>>>> 'does this input halt'. What operations it actually uses to
accomplishes this are entirely irrelevant. You gave the example >>>>>>> of AProVE. This program does not make use of operations which
'see' behaviour (whatever you might mean by that), nor does it
emulate code, nor does it produce a trace up to the point where >>>>>>> it can determine where something halts. It is judged not by these >>>>>>> criteria but rather by whether it actually answers the questions >>>>>>> which it claims to.
Only when we understand that the finite string
transformations of all deciders must be relevant
to the decision criteria do we see these things
at this next deeper layer.
You spend a lot of time talking about finite string
transformations, but I don't recall you ever specifically
mentioning a specific finite string transformation. This is just >>>>>>> a buzz word you've picked up. If you really think you can solve >>>>>>> halting via finite string transformations then presumably you can >>>>>>> identify all the transformations involved (using, for example,
GREP syntax).
Andr|-
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
I specify the inherent requirement that deciders
must apply finite string transformations that are
relevant to the decision criteria. This provides
a deeper understanding of the nature of deciders.
You've given a few non-controversial definitions which don't
mention any actual finite string transformation rules.
So give me an example of such as finite string transformation rule
relevant to deciding a particular language (For example, the
language which describes all halting machines). Specify an *actual* >>>>> rule. Don't just talk in terms of vague generalities. Again, GREP
syntax would be appropriate for your example.
I have done this for four years now.
What is the category of finite string transformation
that HHH could apply to the C source code of DD?
That's a question. And a rather poorly-posed one at that. I asked for
an *example* of a finite string transformation rule.
What exactly is the 'category' of a finite string transformation?
That question doesn't even make sense.
An actual rule would take the form of
String A -> String B
Explain exactly what A and B are here. GREP/Regex would be an
appropriate syntax for specifying this. Vague handwaving wouldn't be.
Andr|-
What category of a finite string transformation
rule does strcmp() to derive 0 or non-zero?
That's not even a coherent question.
Andr|-
Peter,
-a-a "Turing equivalent computation is utterly
-a-a-a restricted to the former."
Of course a Turing-computable analyzer performs computational steps.
BUT SO DOES THE PROGRAM BEING ANALYZED.
You are confusing two distinct computations:
1. The computation performed by the analyzer H.
2. The computation performed by its input D.
Both are perfectly legitimate Turing computations.
There is NO requirement that their execution traces be identical.
-a-a "In those cases where D does not call H(D)
-a-a-a its own decider (1) is a proxy for (2)."
An analyzer can reason about a program without simulating it, whether or
not that program calls the analyzer.
If H happens to simulate D, that is an implementation choice.
NOT A REQUIREMENT OF COMPUTABILITY THEORY.
-a-a "And these results must be [...] equivalent
-a-a-a to the behavior of f simulated by H."
YES!
The RESULT must agree with the actual termination behavior of f.
The COMPUTATION producing that result need not reproduce f's execution.--
And you have just acknowledged that a ranking-function argument provides
a shortcut to simulation.
GOOD.
THEN SIMULATION IS NOT REQUIRED.
-a-a "If it is not examining the sequence of steps
-a-a-a at least at some level of abstraction then it
-a-a-a cannot possibly determine whether or not this
-a-a-a sequence of steps does reach a final state."
You are now confusing ANALYZING a program's transition rules with RECONSTRUCTING its execution trace.
A ranking function proves termination by establishing a decreasing, well-founded measure.
An invariant can establish nontermination by proving that execution
remains forever in a nonterminal region.
Neither technique requires enumerating the execution trace.
And both can be implemented by Turing-computable algorithms.
-a-a "Since the bottom line of correctness must be
-a-a-a equivalent to D simulated by H the actual
-a-a-a behavior of D simulated by H would be the
-a-a-a most definitive measure of this."
NO.
The definitive criterion is the behavior of D under its specified
execution semantics.
A simulator is merely one method of investigating that behavior.
A simulator that aborts, changes the execution context, or fails to reproduce the relevant machine state cannot simply declare its
observations definitive.
-a-a "H1(D) derives the exact same steps as
-a-a-a int main() { D(); }
-a-a-a H(D) does not derive these exact same steps
-a-a-a because D calls H(D) in recursive simulation."
THEN YOU ARE DESCRIBING TWO DIFFERENT EXECUTION CONTEXTS.
If H1 and H do not reproduce the same conditions, their execution traces need not coincide.
That is a property of your implementations.
NOT A LIMITATION OF TURING COMPUTATION.
And the standard Halting Theorem does not assume that H works by
recursively simulating D.
It assumes that H is a TOTAL, CORRECT, COMPUTABLE halting decider.
HOW H OBTAINS ITS ANSWER IS IRRELEVANT.
-a-a "In other cases H act like
-a-a-a unify_with_occurs_check() and rejects
-a-a-a the pathological self-reference."
AND HERE IS YOUR NEW CONFUSION.
In Prolog, `unify_with_occurs_check/2` prevents certain cyclic term constructions.
It does NOT establish that self-referential computations are impossible.
It does NOT establish that recursive programs are invalid.
And it certainly does NOT establish that diagonal computations lie
outside Turing computation.
You are confusing a restriction on term unification with a theorem about computability.
A Turing machine can simulate recursive calls.
It can simulate programs that refer to their own descriptions.
It can simulate computations that never terminate.
THERE IS NOTHING "PATHOLOGICAL" ABOUT THESE COMPUTATIONS.
The limitation is that no Turing-computable algorithm can correctly
DECIDE halting for every arbitrary program and input.
And now you propose that H should reject D because it recognizes self- reference.
REJECT IT AS WHAT, PETER?
If rejection means "D does not halt", then you must PROVE that
conclusion correct.
If rejection means "D is invalid", then you have excluded a valid
program from your alleged universal decider's domain.
If rejection means "H cannot decide", then H is not a total halting
decider.
NONE OF THESE REFUTES THE HALTING THEOREM.
In fact, your analogy with `unify_with_occurs_check()` exposes your fundamental mistake.
You are treating an implementation-specific rejection rule as though it established a fundamental impossibility of computation.
IT DOES NOT.
And declaring the diagonal input "pathological" does not make the
diagonal argument disappear.
It merely means that your proposed H refuses to handle precisely the
case a universal decider MUST handle.
So here is ONE question:
WHEN H "REJECTS" D, DOES IT RETURN "DOES NOT HALT", "INVALID INPUT", OR "UNABLE TO DECIDE"?
WHICH ONE?
And please do not confuse the inability of YOUR simulator to process an input with the inability of a Turing machine to compute its behavior.
THEY ARE NOT THE SAME THING.
Peter,
-a-a "There never was any program being analyzed.
-a-a-a It has always been a static finite [string]
-a-a-a of what is essentially source code."
FOR FUCK'S SAKE.
A program's source code IS a finite string.
And that string SPECIFIES a computation.
THAT IS THE WHOLE POINT OF COMPUTABILITY THEORY.--
Nobody claims that H must physically execute its input.
-a-a "ALL Turing equivalent Computation must be able
-a-a-a to be reduced to applying finite string
-a-a-a transformations to finite string inputs"
YES!
INCLUDING STATIC ANALYSIS.
INCLUDING MATHEMATICAL PROOFS.
INCLUDING THE DIAGONAL CONSTRUCTION.
You have just restated a standard fact about computability and somehow convinced yourself it refutes computability theory.
-a-a "The ultimate measure [...] is D simulated by H."
NO.
The ultimate criterion is whether D HALTS under its specified semantics.
YOUR SIMULATOR IS NOT THE ARBITER OF MATHEMATICAL TRUTH.
And you STILL haven't answered the question:
When H rejects D, does that mean:
- D DOES NOT HALT?
- D IS INVALID?
- H CANNOT DECIDE?
PICK ONE.
You have spent 22 years confusing a program's description, its
execution, and your simulator's behavior.
And you still cannot answer a three-choice question about your own algorithm.
Peter,
-a-a "H(D) must take into account that
-a-a-a D calls H(D) in recursive simulation."
ONLY IF H WORKS BY RECURSIVE SIMULATION.
FOR FUCK'S SAKE, HOW MANY TIMES MUST THIS BE EXPLAINED?--
The Halting Theorem does NOT require H to simulate D.
It requires H to return a correct answer for every valid program.
INCLUDING D.
If H gets trapped in recursive simulation, H is not total.
If H rejects D, you must explain what that rejection means.
If H returns a halting verdict, diagonalization produces the contradiction.
THERE IS NO FOURTH POSSIBILITY THAT INVALIDATES THE THEOREM.
And once again, you have completely ignored my question.
WHEN H REJECTS D, DOES IT MEAN:
1. D does not halt?
2. D is invalid?
3. H cannot decide?
PICK ONE, PETER.
Stop hiding behind your simulator and ANSWER THE FUCKING QUESTION.
On 11/12/26 12:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does
_not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
still not infinitely recursive it is actually just a simple non-
terminating loop of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
polcott u still haven't responded to the fact HHH classifies both
halting DD and non-halting DD2 into the same set of machines with the
same semantic halting behavior...
this is truly a 1 = 0 type of fault
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates one
step of recursion, not infinite. the infinite recursion only occurs
if HHH doesn't break the invariant of letting the simulation run, but
HHH does break that invariant, so invalidating the induction requires
to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical" >>>>
HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive
sipser said that same thing polcott
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT
correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial
recursion is demonstrated. HHH only actually demonstrates one step of
recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH
does break that invariant, so invalidating the induction requires to
prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does
_not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
still not infinitely recursive it is actually just a simple non-
terminating loop of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates one
step of recursion, not infinite. the infinite recursion only occurs
if HHH doesn't break the invariant of letting the simulation run, but
HHH does break that invariant, so invalidating the induction requires
to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical" >>>>
HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive
sipser said that same thing polcott
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
and nowhere does it mention HHH1. seriously bro i
have poured over ur comments before and u not giving me the same respect back for literally 7 lines of code, 6 of which is urs i only changed one
for DD2...
my comment is that DD and DD2 are both classified as having the same semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2
does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2
is still not infinitely recursive it is actually just a simple non-
terminating loop of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates
one step of recursion, not infinite. the infinite recursion only
occurs if HHH doesn't break the invariant of letting the simulation
run, but HHH does break that invariant, so invalidating the
induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that DD
is recursive
sipser said that same thing polcott
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
-aand nowhere does it mention HHH1. seriously bro i have poured over ur
comments before and u not giving me the same respect back for
literally 7 lines of code, 6 of which is urs i only changed one for
DD2...
my comment is that DD and DD2 are both classified as having the same
semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a
non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2
does _not_ halt, unlike DD1 which _does_ halt... but in this case
DD2 is still not infinitely recursive it is actually just a simple
non- terminating loop of one repeated state since that is the
simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates
one step of recursion, not infinite. the infinite recursion only
occurs if HHH doesn't break the invariant of letting the simulation >>>>> run, but HHH does break that invariant, so invalidating the
induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that DD >>>>>>> is recursive
sipser said that same thing polcott
On 11/13/26 11:56 AM, olcott wrote:
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
these are not analogous situations:
HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders
HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider
right now ur claiming that HHH correctly classified halting machine DD
and non-halting machine DD2 into the same semantic set without
justifying how or why this ought to be so... or even acknowledging that
it does so
-aand nowhere does it mention HHH1. seriously bro i have poured over
ur comments before and u not giving me the same respect back for
literally 7 lines of code, 6 of which is urs i only changed one for
DD2...
my comment is that DD and DD2 are both classified as having the same
semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a
non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2
does _not_ halt, unlike DD1 which _does_ halt... but in this case
DD2 is still not infinitely recursive it is actually just a simple
non- terminating loop of one repeated state since that is the
simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and >>>>> classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated. HHH only actually demonstrates >>>>>> one step of recursion, not infinite. the infinite recursion only
occurs if HHH doesn't break the invariant of letting the
simulation run, but HHH does break that invariant, so invalidating >>>>>> the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that DD >>>>>>>> is recursive
sipser said that same thing polcott
On 11/13/2026 2:12 PM, dart200 wrote:
On 11/13/26 11:56 AM, olcott wrote:
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
these are not analogous situations:
HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders
HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider
right now ur claiming that HHH correctly classified halting machine DD
and non-halting machine DD2 into the same semantic set without
justifying how or why this ought to be so... or even acknowledging
that it does so
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
-aand nowhere does it mention HHH1. seriously bro i have poured over
ur comments before and u not giving me the same respect back for
literally 7 lines of code, 6 of which is urs i only changed one for
DD2...
my comment is that DD and DD2 are both classified as having the same
semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a
non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2 >>>>>> does _not_ halt, unlike DD1 which _does_ halt... but in this case >>>>>> DD2 is still not infinitely recursive it is actually just a simple >>>>>> non- terminating loop of one repeated state since that is the
simplest loop
ur "decider" is equating the binary semantic halting behaviors of >>>>>> machine terminating machine DD and non-terminating machine DD2,
and classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short
after the initial recursion is demonstrated. HHH only actually
demonstrates one step of recursion, not infinite. the infinite
recursion only occurs if HHH doesn't break the invariant of
letting the simulation run, but HHH does break that invariant, so >>>>>>> invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that >>>>>>>>> DD is recursive
sipser said that same thing polcott
On 11/13/26 12:19 PM, olcott wrote:
On 11/13/2026 2:12 PM, dart200 wrote:
On 11/13/26 11:56 AM, olcott wrote:
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
these are not analogous situations:
HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders
HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider
right now ur claiming that HHH correctly classified halting machine
DD and non-halting machine DD2 into the same semantic set without
justifying how or why this ought to be so... or even acknowledging
that it does so
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
ok to clarify:
HHH is _not_ a halting semantics decider,
it's more of a "semantically grounded for halting semantics" decider?
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Peter,
-a-a "H only applies finite string transformations
-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
It does NOT imply that H must simulate D.
And your particular simulator does NOT define the semantics of D.
You have now evaded the SAME QUESTION THREE TIMES.
When H rejects D, does it mean:
1. D does not halt?
2. D is invalid?
3. H cannot decide?
PICK ONE.
Your endless repetition about finite strings is not an answer.--
It is a smokescreen.
After 22 years, surely you can explain what your own program's output
means.
Peter,
-a-a "H only applies finite string transformations
-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
It does NOT imply that H must simulate D.
And your particular simulator does NOT define the semantics of D.--
You have now evaded the SAME QUESTION THREE TIMES.
When H rejects D, does it mean:
1. D does not halt?
2. D is invalid?
3. H cannot decide?
PICK ONE.
Your endless repetition about finite strings is not an answer.
It is a smokescreen.
After 22 years, surely you can explain what your own program's output
means.
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to something.
Andr|-
Peter,--
-a-a "Not with TMs."
BULLSHIT.
A Turing machine operates on finite symbols using a finite set of
transition rules. Every finite computation can be described by finite symbolic transformations.
Your distinction is imaginary.
-a-a "As soon as you accept this one half step
-a-a-a we will move onto the other half."
ACCEPT WHAT, EXACTLY?
You haven't stated a proposition that establishes anything about the
Halting Theorem.
And you STILL refuse to explain what H means when it rejects D.
This is not a mathematical proof.
It's a hostage negotiation conducted in half-steps.
After 22 years of research, you apparently need my permission to finish
a sentence.
STATE YOUR CLAIM.
DEFINE YOUR TERMS.
ANSWER THE QUESTION.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a "H only applies finite string transformations
-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
It does NOT imply that H must simulate D.
No I have to add more steps to this so be able
to see other aspects that are inherently required.
I am only going to cover this one half step as
soon as you accept this one half step we will move
onto the other half of this same step.
Le 14/11/2026 |a 00:15, olcott a |-crit :
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a "H only applies finite string transformations
-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
It does NOT imply that H must simulate D.
No I have to add more steps to this so be able
to see other aspects that are inherently required.
I am only going to cover this one half step as
soon as you accept this one half step we will move
onto the other half of this same step.
Peter,
-a-a "Not with TMs."
BULLSHIT.--
A Turing machine operates on finite symbols using a finite set of
transition rules. Every finite computation can be described by finite symbolic transformations.
Your distinction is imaginary.
-a-a "As soon as you accept this one half step
-a-a-a we will move onto the other half."
ACCEPT WHAT, EXACTLY?
You haven't stated a proposition that establishes anything about the
Halting Theorem.
And you STILL refuse to explain what H means when it rejects D.
This is not a mathematical proof.
It's a hostage negotiation conducted in half-steps.
After 22 years of research, you apparently need my permission to finish
a sentence.
STATE YOUR CLAIM.
DEFINE YOUR TERMS.
ANSWER THE QUESTION.
On 11/13/2026 5:27 PM, Python wrote:
Le 14/11/2026 |a 00:15, olcott a |-crit :
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a "H only applies finite string transformations
-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
It does NOT imply that H must simulate D.
No I have to add more steps to this so be able
to see other aspects that are inherently required.
I am only going to cover this one half step as
soon as you accept this one half step we will move
onto the other half of this same step.
Peter,
-a-a "Not with TMs."
Do not reply to this message as a reply
to the message where you dishonestly erased
the context. Go back to that prior message
and do not erase the context this time.
BULLSHIT.
Peter,
-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
"H only applies finite string transformations
to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
Le 14/11/2026 |a 00:15, olcott a |-crit :
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a "H only applies finite string transformations
-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
It does NOT imply that H must simulate D.
No I have to add more steps to this so be able
to see other aspects that are inherently required.
I am only going to cover this one half step as
soon as you accept this one half step we will move
onto the other half of this same step.
Peter,
-a-a "Not with TMs."
BULLSHIT.
A Turing machine operates on finite symbols using a finite set of
transition rules. Every finite computation can be described by finite symbolic transformations.
Your distinction is imaginary.--
-a-a "As soon as you accept this one half step
-a-a-a we will move onto the other half."
ACCEPT WHAT, EXACTLY?
You haven't stated a proposition that establishes anything about the
Halting Theorem.
And you STILL refuse to explain what H means when it rejects D.
This is not a mathematical proof.
It's a hostage negotiation conducted in half-steps.
After 22 years of research, you apparently need my permission to finish
a sentence.
STATE YOUR CLAIM.
DEFINE YOUR TERMS.
ANSWER THE QUESTION.
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
There is never any case where it is directly
reporting on the actual behavior of any
computation.
A halt decider only ever reports on the
result of a sequence of finite string
transformations to finite string inputs.
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
"H only applies finite string transformations
to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to exist, answers a question about a specific computation. There are no 'proxies' involved
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to something. >>>>
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to
exist, answers a question about a specific computation. There are no
'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
Le 14/11/2026 |a 00:49, olcott a |-crit :
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to
something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to
exist, answers a question about a specific computation. There are no
'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a decider somehow addresses any of my points.
And the second paragraph above is entirely incoherent. It's not even a complete sentence. When copying and pasting at least make sure you've
copied the phrase you intended to copy.
Andr|-
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to
something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to
exist, answers a question about a specific computation. There are no
'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine machine behavior. We can at best indirectly examine machine behavior through
finite string proxies that encode sequences of steps.
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE DIFFERENT PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a "When we get rid of these implementation details
-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of computability.
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string rewriting formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for a mathematical breakthrough.
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to
something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to
exist, answers a question about a specific computation. There are
no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine machine
behavior. We can at best indirectly examine machine behavior through
finite string proxies that encode sequences of steps.
You are seriously confused. whether +u* mentions strings, machines, integers, etc. is entirely irrelevant.
A string is a completely
*uninterpreted* sequence of symbols. As soon as you start talking about
a string 'that encodes a sequence of steps' you are no longer talking
about a pure string. You are talking about a string that *represents* something else, and the question being posed to your decider is about
that something else.
Halt deciders ask about computations, not strings. Because of the nature
of Turing Machines, those computations must be encoded as strings, but
the question the decider asks is not about the string; it is about the
thing represented by the string.
Andr|-
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to
something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to
exist, answers a question about a specific computation. There are >>>>>> no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine machine
behavior. We can at best indirectly examine machine behavior through
finite string proxies that encode sequences of steps.
You are seriously confused. whether +u* mentions strings, machines,
integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
We cannot move on to any other points until after
you understand this.
A string is a completely *uninterpreted* sequence of symbols. As soon
as you start talking about a string 'that encodes a sequence of steps'
you are no longer talking about a pure string. You are talking about a
string that *represents* something else, and the question being posed
to your decider is about that something else.
Halt deciders ask about computations, not strings. Because of the
nature of Turing Machines, those computations must be encoded as
strings, but the question the decider asks is not about the string; it
is about the thing represented by the string.
Andr|-
On 11/13/2026 6:28 PM, Python wrote:
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE DIFFERENT
PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a "When we get rid of these implementation details
-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of computability. >>
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string rewriting
formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for a
mathematical breakthrough.
When we look at this through the simplest most
generic abstraction of finite string transformations
to INPUT finite strings thenn (then and only then)
we can begin to look deeper into what categories
of finite string transformations are specifically
relevant to specific decision criteria.
strcmp() must compare strings
halt deciders must examine behavior
On 11/13/26 4:48 PM, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>> something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to >>>>>>> exist, answers a question about a specific computation. There are >>>>>>> no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine
machine behavior. We can at best indirectly examine machine behavior
through finite string proxies that encode sequences of steps.
You are seriously confused. whether +u* mentions strings, machines,
integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
... the halt decision is in respect to the behavior of the machine
defined by the string ...
Le 14/11/2026 |a 01:40, olcott a |-crit :
On 11/13/2026 6:28 PM, Python wrote:
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
DIFFERENT PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a-a "When we get rid of these implementation details
-a-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of
computability.
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string rewriting
formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for a
mathematical breakthrough.
When we look at this through the simplest most
generic abstraction of finite string transformations
to INPUT finite strings thenn (then and only then)
we can begin to look deeper into what categories
of finite string transformations are specifically
relevant to specific decision criteria.
strcmp() must compare strings
halt deciders must examine behavior
Peter,
-a-a "strcmp() must compare strings
-a-a-a halt deciders must examine behavior"
FOR FUCK'S SAKE.
A halting decider must DETERMINE WHETHER A PROGRAM HALTS.
That is its specification.
HOW it determines the answer is an [MANDATORY] implementation detail.
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to
something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to
exist, answers a question about a specific computation. There are >>>>>> no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine machine
behavior. We can at best indirectly examine machine behavior through
finite string proxies that encode sequences of steps.
You are seriously confused. whether +u* mentions strings, machines,
integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
We cannot move on to any other points until after
you understand this.
On 2026-11-13 17:48, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>> something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to >>>>>>> exist, answers a question about a specific computation. There are >>>>>>> no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine
machine behavior. We can at best indirectly examine machine behavior
through finite string proxies that encode sequences of steps.
You are seriously confused. whether +u* mentions strings, machines,
integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
No. That is simply a statement reflecting your disconnect from reality. Finite strings can represent any number of things, including
computations.
I've given you examples in the past which you have
ignored. For example, is the string '10' even or odd? Answer. It's not
even a coherent question. Evenness is a property of natural numbers, not strings. Yet the evenness of a number is perfectly computable.
We cannot move on to any other points until after
you understand this.
You present a claim which is patently false and then claim we cannot
'move on' until I accept your point. That's not going to happen. Your
point is simply wrong.
Andr|-
On 11/13/2026 6:50 PM, dart200 wrote:
On 11/13/26 4:48 PM, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:You are seriously confused. whether +u* mentions strings, machines,
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>>> something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things to >>>>>>>> exist, answers a question about a specific computation. There >>>>>>>> are no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a
decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine
machine behavior. We can at best indirectly examine machine
behavior through finite string proxies that encode sequences of steps. >>>>
integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
... the halt decision is in respect to the behavior of the machine
defined by the string ...
That has ALWAYS been counter-factual
and can only be seen as counter-factual
when one pays enormously more attention
to the actual details than anyone has
ever paid before.
On 11/13/26 5:02 PM, olcott wrote:
On 11/13/2026 6:50 PM, dart200 wrote:
On 11/13/26 4:48 PM, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H)
Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>>>> something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things >>>>>>>>> to exist, answers a question about a specific computation.
There are no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
I have absolutely no idea why you think giving a definition of a >>>>>>> decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine
machine behavior. We can at best indirectly examine machine
behavior through finite string proxies that encode sequences of
steps.
You are seriously confused. whether +u* mentions strings, machines, >>>>> integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
... the halt decision is in respect to the behavior of the machine
defined by the string ...
That has ALWAYS been counter-factual
and can only be seen as counter-factual
when one pays enormously more attention
to the actual details than anyone has
ever paid before.
lol, polcott what does "counter-factual" mean to you?
On 11/13/2026 10:19 PM, dart200 wrote:
On 11/13/26 5:02 PM, olcott wrote:
On 11/13/2026 6:50 PM, dart200 wrote:
On 11/13/26 4:48 PM, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0
(I need to simplify my repository and go back to D/H) >>>>>>>>>>>>> Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH.
Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>>>>> something.
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things >>>>>>>>>> to exist, answers a question about a specific computation. >>>>>>>>>> There are no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting >>>>>>>>
I have absolutely no idea why you think giving a definition of a >>>>>>>> decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine
machine behavior. We can at best indirectly examine machine
behavior through finite string proxies that encode sequences of >>>>>>> steps.
You are seriously confused. whether +u* mentions strings, machines, >>>>>> integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
... the halt decision is in respect to the behavior of the machine
defined by the string ...
That has ALWAYS been counter-factual
and can only be seen as counter-factual
when one pays enormously more attention
to the actual details than anyone has
ever paid before.
lol, polcott what does "counter-factual" mean to you?
PROVEN FALSE ON THE BASIS OF ITS MEANING.
The behavior of x(y) is specified by the
input to H(x,y) ONLY when x does not call H(x,y).
On 11/13/2026 7:01 PM, Python wrote:
Le 14/11/2026 |a 01:40, olcott a |-crit :
On 11/13/2026 6:28 PM, Python wrote:
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
DIFFERENT PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a-a "When we get rid of these implementation details
-a-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of
computability.
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string rewriting
formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for a
mathematical breakthrough.
When we look at this through the simplest most
generic abstraction of finite string transformations
to INPUT finite strings thenn (then and only then)
we can begin to look deeper into what categories
of finite string transformations are specifically
relevant to specific decision criteria.
strcmp() must compare strings
halt deciders must examine behavior
Peter,
-a-a "strcmp() must compare strings
-a-a-a halt deciders must examine behavior"
FOR FUCK'S SAKE.
A halting decider must DETERMINE WHETHER A PROGRAM HALTS.
That is its specification.
HOW it determines the answer is an [MANDATORY] implementation detail.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
On 11/13/26 9:02 PM, olcott wrote:
On 11/13/2026 10:19 PM, dart200 wrote:
On 11/13/26 5:02 PM, olcott wrote:
On 11/13/2026 6:50 PM, dart200 wrote:
On 11/13/26 4:48 PM, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0Either DD halts or it doesn't. It doesn't halt "relative" >>>>>>>>>>>>> to something.
(I need to simplify my repository and go back to D/H) >>>>>>>>>>>>>> Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH. >>>>>>>>>>>>>
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such things >>>>>>>>>>> to exist, answers a question about a specific computation. >>>>>>>>>>> There are no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty >>>>>>>>>> string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting >>>>>>>>>
I have absolutely no idea why you think giving a definition of >>>>>>>>> a decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine >>>>>>>> machine behavior. We can at best indirectly examine machine
behavior through finite string proxies that encode sequences of >>>>>>>> steps.
You are seriously confused. whether +u* mentions strings,
machines, integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
... the halt decision is in respect to the behavior of the machine
defined by the string ...
That has ALWAYS been counter-factual
and can only be seen as counter-factual
when one pays enormously more attention
to the actual details than anyone has
ever paid before.
lol, polcott what does "counter-factual" mean to you?
PROVEN FALSE ON THE BASIS OF ITS MEANING.
that's not what a counter-factual is:
a counter-factual is a hypothetical implication based on a false premise
The behavior of x(y) is specified by the
input to H(x,y) ONLY when x does not call H(x,y).
ironically HHH(DD)->0 is based on the counter-factual reasoning that if
HHH had let DD run, then it would be non-terminating
this is counterfactual because clearly HHH does not let DD run forever,
it cuts off the simulation of DD in order to return 0
Le 14/11/2026 |a 02:10, olcott a |-crit :
On 11/13/2026 7:01 PM, Python wrote:
Le 14/11/2026 |a 01:40, olcott a |-crit :
On 11/13/2026 6:28 PM, Python wrote:
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
DIFFERENT PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a-a "When we get rid of these implementation details
-a-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of
computability.
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string rewriting >>>>> formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for a
mathematical breakthrough.
When we look at this through the simplest most
generic abstraction of finite string transformations
to INPUT finite strings thenn (then and only then)
we can begin to look deeper into what categories
of finite string transformations are specifically
relevant to specific decision criteria.
strcmp() must compare strings
halt deciders must examine behavior
Peter,
-a-a-a "strcmp() must compare strings
-a-a-a-a halt deciders must examine behavior"
FOR FUCK'S SAKE.
A halting decider must DETERMINE WHETHER A PROGRAM HALTS.
That is its specification.
HOW it determines the answer is an [MANDATORY] implementation detail.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
Peter,
YOU HAVE JUST FALSIFIED MY WORDS.
I wrote:
-a-a "HOW it determines the answer is an
-a-a-a implementation detail."
You quoted me as writing:
-a-a "HOW it determines the answer is an
-a-a-a [MANDATORY] implementation detail."
I DID NOT WRITE "[MANDATORY]".
YOU INSERTED IT.
And that insertion changes the meaning of my statement.
You also deleted virtually my entire argument, including the questions
you have repeatedly refused to answer.
Trimming quotations is normal.
ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS NOT.
And then you repeat:
-a-a "To fully understand what the Hell is
-a-a-a actually going on."
FIVE TIMES.
Well, Peter, here's something you should understand:
YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.
You have repeatedly accused others of dishonesty.
NOW LOOK AT WHAT YOU JUST DID.
On 11/14/2026 4:53 AM, Python wrote:
Le 14/11/2026 |a 02:10, olcott a |-crit :
On 11/13/2026 7:01 PM, Python wrote:
Le 14/11/2026 |a 01:40, olcott a |-crit :
On 11/13/2026 6:28 PM, Python wrote:
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations
-a-a-a-a-a to its actual static finite string inputs."
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
DIFFERENT PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a-a "When we get rid of these implementation details
-a-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of
computability.
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string rewriting >>>>>> formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for a >>>>>> mathematical breakthrough.
When we look at this through the simplest most
generic abstraction of finite string transformations
to INPUT finite strings thenn (then and only then)
we can begin to look deeper into what categories
of finite string transformations are specifically
relevant to specific decision criteria.
strcmp() must compare strings
halt deciders must examine behavior
Peter,
-a-a-a "strcmp() must compare strings
-a-a-a-a halt deciders must examine behavior"
FOR FUCK'S SAKE.
A halting decider must DETERMINE WHETHER A PROGRAM HALTS.
That is its specification.
HOW it determines the answer is an [MANDATORY] implementation detail.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
Peter,
YOU HAVE JUST FALSIFIED MY WORDS.
I wrote:
-a-a "HOW it determines the answer is an
-a-a-a implementation detail."
You quoted me as writing:
-a-a "HOW it determines the answer is an
-a-a-a [MANDATORY] implementation detail."
I DID NOT WRITE "[MANDATORY]".
YOU INSERTED IT.
And that insertion changes the meaning of my statement.
Yes and I used standard syntax to indicate that it was inserted.
You also deleted virtually my entire argument, including the questions
you have repeatedly refused to answer.
Trimming quotations is normal.
ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS NOT. >>
And then you repeat:
-a-a "To fully understand what the Hell is
-a-a-a actually going on."
FIVE TIMES.
You seem to have a great difficulty paying close attention.
Richard says that he has ADD and the repetition did help
him focus.
Well, Peter, here's something you should understand:
YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.
You have repeatedly accused others of dishonesty.
NOW LOOK AT WHAT YOU JUST DID.
I used standard syntax to indicate that [MANDATORY] was inserted.
I used standard syntax to indicate that [MANDATORY] was inserted.
I used standard syntax to indicate that [MANDATORY] was inserted.
I used standard syntax to indicate that [MANDATORY] was inserted.
In order to deeply understand what the Hell is going
on implementation details must be addressed at some
level of abstraction.
By applying finite string transformation rules to finite
string inputs to derive any and all outputs.
We see two things:
(1) Any result that cannot be derived this way is outside
the scope of Turing commutable functions the same way that
filling your tires with air is outside the scope of your
toaster.
(2) Within this simplest Turing equivalent model of
computation we can examine the notion of deciders more
deeply.
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
All non-trivial deciders must inherently apply finite string
transformations that are relevant to their decision criteria.
All halt deciders must inherently apply finite string
transformations that are relevant to the behavior specified
by their input finite string.
Le 14/11/2026 |a 15:36, olcott a |-crit :
On 11/14/2026 4:53 AM, Python wrote:
Le 14/11/2026 |a 02:10, olcott a |-crit :
On 11/13/2026 7:01 PM, Python wrote:
Le 14/11/2026 |a 01:40, olcott a |-crit :
On 11/13/2026 6:28 PM, Python wrote:
Le 14/11/2026 |a 01:18, olcott a |-crit :
On 11/13/2026 6:04 PM, Python wrote:
Le 14/11/2026 |a 00:49, olcott a |-crit :So you never heard of move tape_head left?
On 11/13/2026 5:20 PM, Python wrote:
Peter,On 11/13/2026 5:15 PM, olcott wrote:
-a-a-a "Not with TMs."
BULLSHIT.
On 11/13/2026 4:13 PM, Python wrote:
Peter,
-a-a-a-a "H only applies finite string transformations >>>>>>>>>> -a>>-a-a-a-a-a to its actual static finite string inputs." >>>>>>>>>> -a>>
YES. WE KNOW.
THAT IS HOW COMPUTABLE ALGORITHMS WORK.
Not with TMs. With TMs there are a large number
of distracting implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
With TMs there are a large number of distracting
implementation specific details.
No, there are not.
When we look at the whole undivided category
of applying finite string transformations to
finite string inputs, this is the whole kit
and caboodle of computation.
No tape_head moves, no read tape element write
tape element. When we get rid of these
implementation details thenn (then and only then)
can we focus on what categories of finite string
transformations are inherently required for
each type of decider.
We examine every detail of the whole process
to see what is really going on.
Peter,
-a-a-a "So you never heard of move tape_head left?"
FOR FUCK'S SAKE.
Yes, Peter. A Turing machine has a tape head.
A C program has variables.
A lambda calculus expression has beta-reductions.
A string rewriting system has rewriting rules.
CONGRATULATIONS.
YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
DIFFERENT PRIMITIVES.
That is precisely why we study their computational equivalence.
-a-a-a "When we get rid of these implementation details
-a-a-a-a thenn (then and only then) can we focus..."
NO.
Removing the tape head does not magically reveal new laws of
computability.
It merely replaces one Turing-complete formalism with another.
And any universal halting decider in your favorite string
rewriting formalism would yield one for Turing machines.
WHICH DIAGONALIZATION RULES OUT.
After 22 years, you are still mistaking a change of notation for >>>>>>> a mathematical breakthrough.
When we look at this through the simplest most
generic abstraction of finite string transformations
to INPUT finite strings thenn (then and only then)
we can begin to look deeper into what categories
of finite string transformations are specifically
relevant to specific decision criteria.
strcmp() must compare strings
halt deciders must examine behavior
Peter,
-a-a-a "strcmp() must compare strings
-a-a-a-a halt deciders must examine behavior"
FOR FUCK'S SAKE.
A halting decider must DETERMINE WHETHER A PROGRAM HALTS.
That is its specification.
HOW it determines the answer is an [MANDATORY] implementation detail. >>>>>
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
To fully understand what the Hell is actually going on.
Peter,
YOU HAVE JUST FALSIFIED MY WORDS.
I wrote:
-a-a-a "HOW it determines the answer is an
-a-a-a-a implementation detail."
You quoted me as writing:
-a-a-a "HOW it determines the answer is an
-a-a-a-a [MANDATORY] implementation detail."
I DID NOT WRITE "[MANDATORY]".
YOU INSERTED IT.
And that insertion changes the meaning of my statement.
Yes and I used standard syntax to indicate that it was inserted.
You also deleted virtually my entire argument, including the
questions you have repeatedly refused to answer.
Trimming quotations is normal.
ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS
NOT.
And then you repeat:
-a-a-a "To fully understand what the Hell is
-a-a-a-a actually going on."
FIVE TIMES.
You seem to have a great difficulty paying close attention.
Richard says that he has ADD and the repetition did help
him focus.
Well, Peter, here's something you should understand:
YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.
You have repeatedly accused others of dishonesty.
NOW LOOK AT WHAT YOU JUST DID.
I used standard syntax to indicate that [MANDATORY] was inserted.
I used standard syntax to indicate that [MANDATORY] was inserted.
I used standard syntax to indicate that [MANDATORY] was inserted.
I used standard syntax to indicate that [MANDATORY] was inserted.
In order to deeply understand what the Hell is going
on implementation details must be addressed at some
level of abstraction.
By applying finite string transformation rules to finite
string inputs to derive any and all outputs.
We see two things:
(1) Any result that cannot be derived this way is outside
the scope of Turing commutable functions the same way that
filling your tires with air is outside the scope of your
toaster.
(2) Within this simplest Turing equivalent model of
computation we can examine the notion of deciders more
deeply.
the set of all finite strings over +u, including the empty
string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u*
if and only if, for every input w ree +u*, M halts, accepting
if w ree L and rejecting if w ree L.
All non-trivial deciders must inherently apply finite string
transformations that are relevant to their decision criteria.
All halt deciders must inherently apply finite string
transformations that are relevant to the behavior specified
by their input finite string.
Peter,
-a-a "I used standard syntax to indicate that
-a-a-a [MANDATORY] was inserted."
Yes, the brackets indicate an editorial insertion.
They do NOT give you permission to insert a word that reverses the
meaning of my statement and then argue against the resulting distortion.
If you disagree with my statement, QUOTE IT CORRECTLY AND STATE YOUR OBJECTION SEPARATELY.
Now, to the mathematics.
You finally quote the correct definition:
-a-a "A Turing machine M decides a language L
-a-a-a if and only if, for every input w, M halts,
-a-a-a accepting if w belongs to L and rejecting otherwise."
EXACTLY.
Notice what that definition DOES NOT SAY.
It does not say that M must simulate the computation described by w.
It does not say that M must reproduce its execution trace.
It does not say that M must use any particular kind of analysis.
It specifies TOTALITY AND CORRECTNESS.
NOT AN IMPLEMENTATION STRATEGY.
Then you add:
-a-a "All halt deciders must inherently apply finite
-a-a-a string transformations that are relevant to
-a-a-a the behavior specified by their input finite string."
Fine. Let's grant that.
SO WHAT?
A mathematical proof that a loop terminates is relevant to its behavior.
A ranking function is relevant to its behavior.
A static analysis of its control-flow graph is relevant to its behavior.
NONE OF THESE REQUIRES EXECUTING THE LOOP TO COMPLETION.
Consider:
-a-a int f(unsigned n) {
-a-a-a-a-a-a while (n > 0)
-a-a-a-a-a-a-a-a-a-a --n;
-a-a-a-a-a-a return 0;
-a-a }
We can establish termination for every input by observing that n is a nonnegative integer that strictly decreases whenever the loop executes.
We do not need to simulate every iteration.
Your phrase "relevant to the behavior" does not establish your much
stronger claim that a halting decider MUST simulate its input according
to its operational semantics.
YOU HAVE NOT PROVED THAT IMPLICATION.
And even if you did impose such a restriction, you would merely define a restricted class of deciders.
You would NOT refute the Halting Theorem, which concerns ALL total computable procedures capable of deciding the halting property.
Finally, you write:
-a-a "Any result that cannot be derived this way
-a-a-a is outside the scope of Turing computable functions."
Yes. And if a universal halting decider existed in your string transformation model, its algorithm could be translated into a Turing machine.
The diagonal contradiction would apply unchanged.
YOUR CHANGE OF FORMALISM DOES NOT CHANGE COMPUTABILITY.
So here is the question you keep avoiding:
**WHAT EXACTLY PREVENTS THE DIAGONAL ARGUMENT FROM APPLYING TO YOUR
PROPOSED DECIDER?**
Not a slogan.--
Not a repetition.
Not another definition you invented.
A MATHEMATICAL ARGUMENT.
On 11/14/2026 12:55 AM, dart200 wrote:
On 11/13/26 9:02 PM, olcott wrote:
On 11/13/2026 10:19 PM, dart200 wrote:
On 11/13/26 5:02 PM, olcott wrote:
On 11/13/2026 6:50 PM, dart200 wrote:
On 11/13/26 4:48 PM, olcott wrote:
On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:23, olcott wrote:
On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
On 2026-11-13 17:03, olcott wrote:
On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
On 2026-11-13 16:20, olcott wrote:
On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
On 2026-11-13 14:31, olcott wrote:
HHH(DD)==0Either DD halts or it doesn't. It doesn't halt "relative" >>>>>>>>>>>>>> to something.
(I need to simplify my repository and go back to D/H) >>>>>>>>>>>>>>> Means that DD does not halt relative to HHH or
DD is semantically ill-formed thus bad input to HHH. >>>>>>>>>>>>>>
Andr|-
In every case a halt decider is at most the
proxy for the behavior of a computation.
That's just errant nonsense. A halt decider, were such >>>>>>>>>>>> things to exist, answers a question about a specific
computation. There are no 'proxies' involved
Let +u be a finite, nonempty alphabet, let +u* denote
the set of all finite strings over +u, including the empty >>>>>>>>>>> string +|, and let L rea +u* be a language
Decider. A Turing machine M decides a language L rea +u* >>>>>>>>>>> if and only if, for every input w ree +u*, M halts, accepting >>>>>>>>>>
I have absolutely no idea why you think giving a definition of >>>>>>>>>> a decider somehow addresses any of my points.
+u* has zero machines thus no possible way to directly examine >>>>>>>>> machine behavior. We can at best indirectly examine machine >>>>>>>>> behavior through finite string proxies that encode sequences of >>>>>>>>> steps.
You are seriously confused. whether +u* mentions strings,
machines, integers, etc. is entirely irrelevant.
That computation only operates on strings and never
operates on machines proves that no halt decision
on any input is more than a proxy for the behavior
of any machine.
... the halt decision is in respect to the behavior of the machine >>>>>> defined by the string ...
That has ALWAYS been counter-factual
and can only be seen as counter-factual
when one pays enormously more attention
to the actual details than anyone has
ever paid before.
lol, polcott what does "counter-factual" mean to you?
PROVEN FALSE ON THE BASIS OF ITS MEANING.
that's not what a counter-factual is:
I am stipulating that it what I mean.
3 > 5 is counter-factual.
a counter-factual is a hypothetical implication based on a false premise
The behavior of x(y) is specified by the
input to H(x,y) ONLY when x does not call H(x,y).
ironically HHH(DD)->0 is based on the counter-factual reasoning that
if HHH had let DD run, then it would be non-terminating
Halt deciders are only accountable for determining
the behavior that their input finite string specifies.
this is counterfactual because clearly HHH does not let DD run
forever, it cuts off the simulation of DD in order to return 0
The same way that it would for an infinite loop, stupid.
Peter,
We have finally made some progress.
You explicitly concede:
-a-a "I will grant you that."
And:
-a-a "Yes I will grant you that."
In particular, you now acknowledge that static analysis can establish termination WITHOUT executing every step of the program.
GOOD.
But then you write:
-a-a "These are all simply short cuts to reduce the
-a-a-a time that it takes to perform an actual simulation."
NO.
A mathematical proof of termination is not necessarily an abbreviated simulation.
It can establish a property of ALL possible executions without reconstructing ANY complete execution trace.
You are confusing reasoning ABOUT a computation with PERFORMING that computation.
-a-a "These short-cuts must remain consistent with
-a-a-a what the behavior of the simulation would be"
OF COURSE.
That is called CORRECTNESS.
It does not imply that the analysis must simulate the program.
Now to your latest escape hatch:
-a-a "Type mismatch error."
WHAT TYPE MISMATCH?
The halting problem concerns encoded programs and their inputs.
A hypothetical universal decider H accepts such encodings and returns a Boolean answer.
The diagonal program D is itself a valid program.
Its encoding is a valid input to H.
And D calls H on that encoding.
THERE IS NO TYPE MISMATCH.
Here is the argument, stripped of every irrelevant implementation detail.
Assume H is total and correct.
Define D(x) as follows:
-a-a if H(x, x) says "halts":
-a-a-a-a-a-a loop forever
-a-a else:
-a-a-a-a-a-a halt
Now consider D(D).
If H(D, D) says "halts", D(D) does not halt.
If H(D, D) says "does not halt", D(D) halts.
CONTRADICTION.
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the
shit out of a threads stack... I made a manual recursion for
AppleSoft BASIC for fun while trying to port some of my algos to it:
why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
[...]
Well, basically to see how portable my algos really are. So far, I
have all of my fractals that use recursion, and even some of my n-ary
vector fields! Let me get an older screenshot of it, I posted it in a
BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type checker!
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker- heres-how-types-execute-code-50i1
maybe u can do that one next
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive operations
that compare strings
(The standard libraries do; the language does not).
So exactly which operations is it supposed to use? And if you claim that strcmp() is restricted to rely on strcmp() then you're caught in an infinitely recursive trap.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no restrictions
on which sorts of operations a halt decider can make use of, provided it ultimately returns the correct answer.
Andr|-
On 11/12/2026 6:59 PM, Andr|- G. Isaak wrote:
On 2026-11-12 17:48, olcott wrote:
On 11/12/2026 6:32 PM, Python wrote:
Peter,
-a-a-a "when H applies the most relevant finite string
-a-a-a-a transformation / inference steps to its static
-a-a-a-a finite string D, then this input D cannot reach
-a-a-a-a that code."
YOU ARE STILL MISSING THE POINT.
The Halting Theorem does not assume that H works by executing or
simulating D.
strcmp() is limited to those operations that
compare strings.
That's unfortunate, since C doesn't contain *any* primitive operations
that compare strings
We can compare strings in pure C, so std lib whatever.
(The standard libraries do; the language does not). So exactly which
operations is it supposed to use? And if you claim that strcmp() is
restricted to rely on strcmp() then you're caught in an infinitely
recursive trap.
Halt deciders are limited to those operations
that can see behavior.
Operations can't "see" behaviour. And there's absolutely no
restrictions on which sorts of operations a halt decider can make use
of, provided it ultimately returns the correct answer.
Andr|-
On 11/12/2026 1:55 PM, dart200 wrote:
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the
shit out of a threads stack... I made a manual recursion for
AppleSoft BASIC for fun while trying to port some of my algos to it:
why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
[...]
Well, basically to see how portable my algos really are. So far, I
have all of my fractals that use recursion, and even some of my n-ary
vector fields! Let me get an older screenshot of it, I posted it in a
BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type checker!
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker-
heres-how-types-execute-code-50i1
maybe u can do that one next
Well, AppleSoft BASIC is pretty old. If it can go there, which it can,
well, ahhh. That is good enough for me. I started programming with BASIC.
On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
On 11/12/2026 1:55 PM, dart200 wrote:
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short
after the initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the >>>>>> shit out of a threads stack... I made a manual recursion for
AppleSoft BASIC for fun while trying to port some of my algos to it: >>>>>
[...]
Well, basically to see how portable my algos really are. So far, I
have all of my fractals that use recursion, and even some of my n-
ary vector fields! Let me get an older screenshot of it, I posted it
in a BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type checker!
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
checker- heres-how-types-execute-code-50i1
maybe u can do that one next
Well, AppleSoft BASIC is pretty old. If it can go there, which it can,
well, ahhh. That is good enough for me. I started programming with BASIC.
all turing complete languages are convertible to each other, provably so
we don't know any way of describing an executable algorithm that is more powerful in computability than a turing complete language, that therefor
can be run on a turing machine
i'm not sure polcott will ever understand this point to be frank
On 11/15/2026 12:33 AM, dart200 wrote:
On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
On 11/12/2026 1:55 PM, dart200 wrote:
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>>> invariant that HHH not cut DD simulation's short after the >>>>>>>>>> recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short >>>>>>>> after the initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast
the shit out of a threads stack... I made a manual recursion for >>>>>>> AppleSoft BASIC for fun while trying to port some of my algos to it: >>>>>>
[...]
Well, basically to see how portable my algos really are. So far, I
have all of my fractals that use recursion, and even some of my n-
ary vector fields! Let me get an older screenshot of it, I posted
it in a BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type checker! >>>>
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
checker- heres-how-types-execute-code-50i1
maybe u can do that one next
Well, AppleSoft BASIC is pretty old. If it can go there, which it
can, well, ahhh. That is good enough for me. I started programming
with BASIC.
all turing complete languages are convertible to each other, provably so
we don't know any way of describing an executable algorithm that is
more powerful in computability than a turing complete language, that
therefor can be run on a turing machine
i'm not sure polcott will ever understand this point to be frank
Yeah. So I can port it and gain the data. But I also want to plot that
data.
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast the
shit out of a threads stack... I made a manual recursion for
AppleSoft BASIC for fun while trying to port some of my algos to it:
why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
[...]
Well, basically to see how portable my algos really are. So far, I
have all of my fractals that use recursion, and even some of my n-ary
vector fields! Let me get an older screenshot of it, I posted it in a
BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type checker!
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker- heres-how-types-execute-code-50i1
maybe u can do that one next
On 11/15/2026 12:33 AM, dart200 wrote:
On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
On 11/12/2026 1:55 PM, dart200 wrote:
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>>> invariant that HHH not cut DD simulation's short after the >>>>>>>>>> recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short >>>>>>>> after the initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast
the shit out of a threads stack... I made a manual recursion for >>>>>>> AppleSoft BASIC for fun while trying to port some of my algos to it: >>>>>>
[...]
Well, basically to see how portable my algos really are. So far, I
have all of my fractals that use recursion, and even some of my n-
ary vector fields! Let me get an older screenshot of it, I posted
it in a BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type checker! >>>>
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
checker- heres-how-types-execute-code-50i1
maybe u can do that one next
Well, AppleSoft BASIC is pretty old. If it can go there, which it
can, well, ahhh. That is good enough for me. I started programming
with BASIC.
all turing complete languages are convertible to each other, provably so
we don't know any way of describing an executable algorithm that is
more powerful in computability than a turing complete language, that
therefor can be run on a turing machine
i'm not sure polcott will ever understand this point to be frank
Yeah. So I can port it and gain the data. But I also want to plot that
data.
On 11/14/2026 11:02 AM, Python wrote:
Peter,
We have finally made some progress.
You explicitly concede:
-a-a "I will grant you that."
And:
-a-a "Yes I will grant you that."
In particular, you now acknowledge that static analysis can establish
termination WITHOUT executing every step of the program.
GOOD.
I knew that.
But then you write:
-a-a "These are all simply short cuts to reduce the
-a-a-a time that it takes to perform an actual simulation."
NO.
It is only behavior that is consistent with the behavior
of input I simulated by H that measures the behavior of
I AS AN INPUT TO H.
A mathematical proof of termination is not necessarily an abbreviated
simulation.
It can establish a property of ALL possible executions without
reconstructing ANY complete execution trace.
An input that takes no arguments eliminates the
Frederick Brooks (No Silver Bullet Essence and
Accidents of Software Engineering) inessential
complexity of an input with arguments.
You are confusing reasoning ABOUT a computation with PERFORMING that
computation.
-a-a "These short-cuts must remain consistent with
-a-a-a what the behavior of the simulation would be"
OF COURSE.
That is called CORRECTNESS.
Great we are back to mutual agreement.
DD simulated by HHH provides the ultimate basis of
the behavior that DD (AS AN INPUT) specifies to HHH.
Deciders apply finite string transformation /
inference steps to finite string inputs according
to a decision criteria.
It does not imply that the analysis must simulate the program.
Now to your latest escape hatch:
-a-a "Type mismatch error."
WHAT TYPE MISMATCH?
The halting problem concerns encoded programs and their inputs.
A hypothetical universal decider H accepts such encodings and returns a
Boolean answer.
The diagonal program D is itself a valid program.
Its encoding is a valid input to H.
And D calls H on that encoding.
THERE IS NO TYPE MISMATCH.
The type mismatch is the expectation that HHH
reports on the behavior of the executable
process DD() instead of the behavior that the
finite string (AS AN INPUT) specifies to HHH.
Here is the argument, stripped of every irrelevant implementation detail.
Assume H is total and correct.
Define D(x) as follows:
-a-a if H(x, x) says "halts":
-a-a-a-a-a-a loop forever
-a-a else:
-a-a-a-a-a-a halt
Now consider D(D).
If H(D, D) says "halts", D(D) does not halt.
If H(D, D) says "does not halt", D(D) halts.
CONTRADICTION.
// eliminate inessential argument to DD
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03 int Halt_Status = HHH(DD);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 HHH(DD);
12 }
Simulation Trace
Line 11: main() invokes HHH(DD);
Line 03: DD calls HHH(DD); HHH simulates DD;
Line 03: DD calls HHH(DD); HHH simulates DD;
Line 03: DD calls HHH(DD); HHH simulates DD;
Line 03: DD calls HHH(DD); HHH simulates DD; ...
<snip>
Le 15/11/2026 |a 04:38, olcott a |-crit :
On 11/14/2026 11:02 AM, Python wrote:
Peter,
We have finally made some progress.
You explicitly concede:
-a-a-a "I will grant you that."
And:
-a-a-a "Yes I will grant you that."
In particular, you now acknowledge that static analysis can establish
termination WITHOUT executing every step of the program.
GOOD.
I knew that.
But then you write:
-a-a-a "These are all simply short cuts to reduce the
-a-a-a-a time that it takes to perform an actual simulation."
NO.
It is only behavior that is consistent with the behavior
of input I simulated by H that measures the behavior of
I AS AN INPUT TO H.
A mathematical proof of termination is not necessarily an abbreviated
simulation.
It can establish a property of ALL possible executions without
reconstructing ANY complete execution trace.
An input that takes no arguments eliminates the
Frederick Brooks (No Silver Bullet Essence and
Accidents of Software Engineering) inessential
complexity of an input with arguments.
You are confusing reasoning ABOUT a computation with PERFORMING that
computation.
-a-a-a "These short-cuts must remain consistent with
-a-a-a-a what the behavior of the simulation would be"
OF COURSE.
That is called CORRECTNESS.
Great we are back to mutual agreement.
DD simulated by HHH provides the ultimate basis of
the behavior that DD (AS AN INPUT) specifies to HHH.
Deciders apply finite string transformation /
inference steps to finite string inputs according
to a decision criteria.
It does not imply that the analysis must simulate the program.
Now to your latest escape hatch:
-a-a-a "Type mismatch error."
WHAT TYPE MISMATCH?
The halting problem concerns encoded programs and their inputs.
A hypothetical universal decider H accepts such encodings and returns
a Boolean answer.
The diagonal program D is itself a valid program.
Its encoding is a valid input to H.
And D calls H on that encoding.
THERE IS NO TYPE MISMATCH.
The type mismatch is the expectation that HHH
reports on the behavior of the executable
process DD() instead of the behavior that the
finite string (AS AN INPUT) specifies to HHH.
Here is the argument, stripped of every irrelevant implementation
detail.
Assume H is total and correct.
Define D(x) as follows:
-a-a-a if H(x, x) says "halts":
-a-a-a-a-a-a-a loop forever
-a-a-a else:
-a-a-a-a-a-a-a halt
Now consider D(D).
If H(D, D) says "halts", D(D) does not halt.
If H(D, D) says "does not halt", D(D) halts.
CONTRADICTION.
// eliminate inessential argument to DD
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
08
09 void main()
10 {
11-a HHH(DD);
12 }
Simulation Trace
Line 11: main() invokes HHH(DD);
Line 03: DD calls HHH(DD); HHH simulates DD;
-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...
<snip>
Peter,
-a-a "The type mismatch is the expectation that HHH
-a-a-a reports on the behavior of the executable
-a-a-a process DD() instead of the behavior that the
-a-a-a finite string (AS AN INPUT) specifies to HHH."
THERE IS NO TYPE MISMATCH.
A program's encoding is a finite string.
That string describes a program.
The program has an operational semantics.
And the halting problem asks whether the computation described by that encoding terminates.
THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.
You are inventing a distinction between the behavior of a program and
the behavior specified by its encoding.
Those are not two different decision problems.
Now consider your simulation trace:
-a-a main() calls HHH(DD)
-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...
YES, PETER.
YOUR HHH GETS STUCK IN INFINITE RECURSION.
CONGRATULATIONS.
YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.
That is perfectly consistent with the Halting Theorem.
In fact, it is exactly the kind of failure the theorem tells us is unavoidable for any proposed universal decider.
But the diagonal proof does not assume that H works by recursively simulating its input.
IT ASSUMES THAT H IS TOTAL AND CORRECT.
Under that hypothesis, H(DD) returns an answer.
Therefore DD reaches its conditional branch.
And whichever answer H returns, DD does the opposite.
THAT IS THE CONTRADICTION.
You cannot refute a proof about ALL possible computable deciders by exhibiting ONE PARTICULAR DECIDER THAT FAILS.
And your attempt to make the simulator's behavior the "ultimate basis"
of the program's semantics is circular.
A simulator is supposed to reproduce the semantics of the program.
THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.
If your simulator gets stuck, that tells us something about your simulator.--
It does not establish that the program is invalid.
Nor does it establish that a hypothetical total H could avoid the
diagonal contradiction.
Your entire argument amounts to:
"My implementation of H cannot decide D."
YES.
THAT IS WHAT THE HALTING THEOREM PREDICTS.
You have spent 28 years demonstrating an example of the theorem you
claim to have refuted.
On 11/15/2026 5:37 AM, Python wrote:
Le 15/11/2026 |a 04:38, olcott a |-crit :
On 11/14/2026 11:02 AM, Python wrote:
Peter,
We have finally made some progress.
You explicitly concede:
-a-a-a "I will grant you that."
And:
-a-a-a "Yes I will grant you that."
In particular, you now acknowledge that static analysis can establish >>>> termination WITHOUT executing every step of the program.
GOOD.
I knew that.
But then you write:
-a-a-a "These are all simply short cuts to reduce the
-a-a-a-a time that it takes to perform an actual simulation."
NO.
It is only behavior that is consistent with the behavior
of input I simulated by H that measures the behavior of
I AS AN INPUT TO H.
A mathematical proof of termination is not necessarily an abbreviated >>>> simulation.
It can establish a property of ALL possible executions without
reconstructing ANY complete execution trace.
An input that takes no arguments eliminates the
Frederick Brooks (No Silver Bullet Essence and
Accidents of Software Engineering) inessential
complexity of an input with arguments.
You are confusing reasoning ABOUT a computation with PERFORMING that
computation.
-a-a-a "These short-cuts must remain consistent with
-a-a-a-a what the behavior of the simulation would be"
OF COURSE.
That is called CORRECTNESS.
Great we are back to mutual agreement.
DD simulated by HHH provides the ultimate basis of
the behavior that DD (AS AN INPUT) specifies to HHH.
Deciders apply finite string transformation /
inference steps to finite string inputs according
to a decision criteria.
It does not imply that the analysis must simulate the program.
Now to your latest escape hatch:
-a-a-a "Type mismatch error."
WHAT TYPE MISMATCH?
The halting problem concerns encoded programs and their inputs.
A hypothetical universal decider H accepts such encodings and returns >>>> a Boolean answer.
The diagonal program D is itself a valid program.
Its encoding is a valid input to H.
And D calls H on that encoding.
THERE IS NO TYPE MISMATCH.
The type mismatch is the expectation that HHH
reports on the behavior of the executable
process DD() instead of the behavior that the
finite string (AS AN INPUT) specifies to HHH.
Here is the argument, stripped of every irrelevant implementation
detail.
Assume H is total and correct.
Define D(x) as follows:
-a-a-a if H(x, x) says "halts":
-a-a-a-a-a-a-a loop forever
-a-a-a else:
-a-a-a-a-a-a-a halt
Now consider D(D).
If H(D, D) says "halts", D(D) does not halt.
If H(D, D) says "does not halt", D(D) halts.
CONTRADICTION.
// eliminate inessential argument to DD
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
08
09 void main()
10 {
11-a HHH(DD);
12 }
Simulation Trace
Line 11: main() invokes HHH(DD);
Line 03: DD calls HHH(DD); HHH simulates DD;
-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...
<snip>
Peter,
-a-a "The type mismatch is the expectation that HHH
-a-a-a reports on the behavior of the executable
-a-a-a process DD() instead of the behavior that the
-a-a-a finite string (AS AN INPUT) specifies to HHH."
THERE IS NO TYPE MISMATCH.
A program's encoding is a finite string.
That string describes a program.
The program has an operational semantics.
And the halting problem asks whether the computation described by that
encoding terminates.
It asks about the behavior of a machine that no
halt decider has direct access to.
The finite string encoding of the machine (as an input)
does specify the behavior of the static finite string
input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
otherwise it is a valid proxy for the behavior of the
underlying machine.
**Computation defined**
Turing equivalent Post canonical systems and semi-Thue
systems are simplified and made generic as follows:
All Turing equivalent computations can be reduced to
applying finite string transformation rules to finite
string inputs to derive any and all outputs.
Deciders only apply finite string transformation/inference
steps to their finite strings AS INPUTS.
They must only apply inference steps that are relevant
to the decision criterion.
Thus for halt deciders these inference steps are restricted
to the operational semantics of the language of computation
of the input.
THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.
You are inventing a distinction between the behavior of a program and
the behavior specified by its encoding.
Those are not two different decision problems.
Now consider your simulation trace:
-a-a main() calls HHH(DD)
-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...
YES, PETER.
YOUR HHH GETS STUCK IN INFINITE RECURSION.
CONGRATULATIONS.
YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.
There are at least two ways that this can be correctly understood:
(1) The behavior that the the input finite string DD
specifies to its halt decider HHH is non-halting behavior.
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
(2) When we hypothesize that HHH is applying a Prolog unify_with_occurs_check() to its input the DD is rejected
as bad input. I report this one because it is exactly the
same process as unify_with_occurs_check(LP, not(true(LP))).
That is perfectly consistent with the Halting Theorem.
In fact, it is exactly the kind of failure the theorem tells us is
unavoidable for any proposed universal decider.
But the diagonal proof does not assume that H works by recursively
simulating its input.
IT ASSUMES THAT H IS TOTAL AND CORRECT.
Under that hypothesis, H(DD) returns an answer.
Therefore DD reaches its conditional branch.
And whichever answer H returns, DD does the opposite.
THAT IS THE CONTRADICTION.
You cannot refute a proof about ALL possible computable deciders by
exhibiting ONE PARTICULAR DECIDER THAT FAILS.
And your attempt to make the simulator's behavior the "ultimate basis"
of the program's semantics is circular.
A simulator is supposed to reproduce the semantics of the program.
THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.
The semantics is the operational semantics of C applied
to the decision criteria as inference steps.
If your simulator gets stuck, that tells us something about your simulator. >>
It does not establish that the program is invalid.
Nor does it establish that a hypothetical total H could avoid the
diagonal contradiction.
Your entire argument amounts to:
"My implementation of H cannot decide D."
YES.
THAT IS WHAT THE HALTING THEOREM PREDICTS.
You have spent 28 years demonstrating an example of the theorem you
claim to have refuted.
On 11/15/26 12:38 AM, Chris M. Thomasson wrote:
On 11/15/2026 12:33 AM, dart200 wrote:
On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
On 11/12/2026 1:55 PM, dart200 wrote:
On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
On 11/12/2026 12:40 PM, dart200 wrote:
On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
On 11/11/2026 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>> words to not conform to their false assumptions.
I can very much better show that these assumptions >>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>> the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on >>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>> the recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>> after the initial recursion is demonstrated.
In reality _traditional_ recursion for too long can/will blast >>>>>>>> the shit out of a threads stack... I made a manual recursion for >>>>>>>> AppleSoft BASIC for fun while trying to port some of my algos to >>>>>>>> it:
why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-
[...]
Well, basically to see how portable my algos really are. So far, I >>>>>> have all of my fractals that use recursion, and even some of my n- >>>>>> ary vector fields! Let me get an older screenshot of it, I posted >>>>>> it in a BASIC group over on the FB... Found it:
https://i.ibb.co/My8QQRdm/image.png
Can you see it?
https://i.ibb.co/My8QQRdm/image.png
wow pretty nuts ...
but not as crazy as porting them to the typescript static type
checker!
https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
checker- heres-how-types-execute-code-50i1
maybe u can do that one next
Well, AppleSoft BASIC is pretty old. If it can go there, which it
can, well, ahhh. That is good enough for me. I started programming
with BASIC.
all turing complete languages are convertible to each other, provably so >>>
we don't know any way of describing an executable algorithm that is
more powerful in computability than a turing complete language, that
therefor can be run on a turing machine
i'm not sure polcott will ever understand this point to be frank
Yeah. So I can port it and gain the data. But I also want to plot that
data.
what data are you gaining and/or plotting from such an exercise?
Le 15/11/2026 |a 15:11, olcott a |-crit :
On 11/15/2026 5:37 AM, Python wrote:
Le 15/11/2026 |a 04:38, olcott a |-crit :
On 11/14/2026 11:02 AM, Python wrote:
Peter,
We have finally made some progress.
You explicitly concede:
-a-a-a "I will grant you that."
And:
-a-a-a "Yes I will grant you that."
In particular, you now acknowledge that static analysis can
establish termination WITHOUT executing every step of the program.
GOOD.
I knew that.
But then you write:
-a-a-a "These are all simply short cuts to reduce the
-a-a-a-a time that it takes to perform an actual simulation."
NO.
It is only behavior that is consistent with the behavior
of input I simulated by H that measures the behavior of
I AS AN INPUT TO H.
A mathematical proof of termination is not necessarily an
abbreviated simulation.
It can establish a property of ALL possible executions without
reconstructing ANY complete execution trace.
An input that takes no arguments eliminates the
Frederick Brooks (No Silver Bullet Essence and
Accidents of Software Engineering) inessential
complexity of an input with arguments.
You are confusing reasoning ABOUT a computation with PERFORMING
that computation.
-a-a-a "These short-cuts must remain consistent with
-a-a-a-a what the behavior of the simulation would be"
OF COURSE.
That is called CORRECTNESS.
Great we are back to mutual agreement.
DD simulated by HHH provides the ultimate basis of
the behavior that DD (AS AN INPUT) specifies to HHH.
Deciders apply finite string transformation /
inference steps to finite string inputs according
to a decision criteria.
It does not imply that the analysis must simulate the program.
Now to your latest escape hatch:
-a-a-a "Type mismatch error."
WHAT TYPE MISMATCH?
The halting problem concerns encoded programs and their inputs.
A hypothetical universal decider H accepts such encodings and
returns a Boolean answer.
The diagonal program D is itself a valid program.
Its encoding is a valid input to H.
And D calls H on that encoding.
THERE IS NO TYPE MISMATCH.
The type mismatch is the expectation that HHH
reports on the behavior of the executable
process DD() instead of the behavior that the
finite string (AS AN INPUT) specifies to HHH.
Here is the argument, stripped of every irrelevant implementation
detail.
Assume H is total and correct.
Define D(x) as follows:
-a-a-a if H(x, x) says "halts":
-a-a-a-a-a-a-a loop forever
-a-a-a else:
-a-a-a-a-a-a-a halt
Now consider D(D).
If H(D, D) says "halts", D(D) does not halt.
If H(D, D) says "does not halt", D(D) halts.
CONTRADICTION.
// eliminate inessential argument to DD
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
08
09 void main()
10 {
11-a HHH(DD);
12 }
Simulation Trace
Line 11: main() invokes HHH(DD);
Line 03: DD calls HHH(DD); HHH simulates DD;
-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...
<snip>
Peter,
-a-a-a "The type mismatch is the expectation that HHH
-a-a-a-a reports on the behavior of the executable
-a-a-a-a process DD() instead of the behavior that the
-a-a-a-a finite string (AS AN INPUT) specifies to HHH."
THERE IS NO TYPE MISMATCH.
A program's encoding is a finite string.
That string describes a program.
The program has an operational semantics.
And the halting problem asks whether the computation described by
that encoding terminates.
It asks about the behavior of a machine that no
halt decider has direct access to.
The finite string encoding of the machine (as an input)
does specify the behavior of the static finite string
input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
otherwise it is a valid proxy for the behavior of the
underlying machine.
**Computation defined**
Turing equivalent Post canonical systems and semi-Thue
systems are simplified and made generic as follows:
All Turing equivalent computations can be reduced to
applying finite string transformation rules to finite
string inputs to derive any and all outputs.
Deciders only apply finite string transformation/inference
steps to their finite strings AS INPUTS.
They must only apply inference steps that are relevant
to the decision criterion.
Thus for halt deciders these inference steps are restricted
to the operational semantics of the language of computation
of the input.
THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.
You are inventing a distinction between the behavior of a program and
the behavior specified by its encoding.
Those are not two different decision problems.
Now consider your simulation trace:
-a-a-a main() calls HHH(DD)
-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...
YES, PETER.
YOUR HHH GETS STUCK IN INFINITE RECURSION.
CONGRATULATIONS.
YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.
There are at least two ways that this can be correctly understood:
(1) The behavior that the the input finite string DD
specifies to its halt decider HHH is non-halting behavior.
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
(2) When we hypothesize that HHH is applying a Prolog
unify_with_occurs_check() to its input the DD is rejected
as bad input. I report this one because it is exactly the
same process as unify_with_occurs_check(LP, not(true(LP))).
That is perfectly consistent with the Halting Theorem.
In fact, it is exactly the kind of failure the theorem tells us is
unavoidable for any proposed universal decider.
But the diagonal proof does not assume that H works by recursively
simulating its input.
IT ASSUMES THAT H IS TOTAL AND CORRECT.
Under that hypothesis, H(DD) returns an answer.
Therefore DD reaches its conditional branch.
And whichever answer H returns, DD does the opposite.
THAT IS THE CONTRADICTION.
You cannot refute a proof about ALL possible computable deciders by
exhibiting ONE PARTICULAR DECIDER THAT FAILS.
And your attempt to make the simulator's behavior the "ultimate
basis" of the program's semantics is circular.
A simulator is supposed to reproduce the semantics of the program.
THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.
The semantics is the operational semantics of C applied
to the decision criteria as inference steps.
If your simulator gets stuck, that tells us something about your
simulator.
It does not establish that the program is invalid.
Nor does it establish that a hypothetical total H could avoid the
diagonal contradiction.
Your entire argument amounts to:
"My implementation of H cannot decide D."
YES.
THAT IS WHAT THE HALTING THEOREM PREDICTS.
You have spent 28 years demonstrating an example of the theorem you
claim to have refuted.
Peter,
-a-a "The finite string encoding of the machine
-a-a-a does specify the behavior [...] EXCEPT WHEN
-a-a-a THE INPUT CALLS ITS OWN DECIDER"
THERE IT IS.
YOUR ENTIRE "REFUTATION" IN ONE SENTENCE.
You accept that program encodings describe program behavior.
EXCEPT WHEN DIAGONALIZATION BECOMES INCONVENIENT.
That exception is not a theorem.
It is something you have INVENTED to escape the contradiction.
A program does not become invalid merely because it calls another
program that analyzes it.
And a hypothetical total halting decider does not acquire an exemption
from its specification when the input happens to call it.
-a-a "Thus for halt deciders these inference steps
-a-a-a are restricted to the operational semantics
-a-a-a of the language of computation of the input."
NO.
A halting decider must give answers consistent with the operational semantics of its input.
It need not perform its analysis by executing those operational
semantics step by step.
YOU HAVE ALREADY CONCEDED THAT STATIC ANALYSIS CAN ESTABLISH TERMINATION WITHOUT FULL SIMULATION.
Now you offer two possibilities:
-a-a "(1) The behavior that the input finite string DD
-a-a-a specifies to its halt decider HHH is non-halting"
Then you have merely shown that YOUR RECURSIVE SIMULATION DOES NOT TERMINATE.
That is not a decision about the halting behavior of DD under the
hypothesis of a total, correct HHH.
You are confusing the behavior of the analyzer with the behavior it is supposed to analyze.
-a-a "(2) [...] DD is rejected as bad input."
ON WHAT GROUNDS?
DD is a syntactically valid program.
Its encoding is a finite string.
It can be executed under a specified implementation of HHH.
There is no type error and no malformed term.
Your Prolog analogy is irrelevant.
-a-a unify_with_occurs_check(X, f(X))
rejects a cyclic first-order substitution.
DD IS NOT A CYCLIC FIRST-ORDER SUBSTITUTION.
A recursive call is not an occurs-check violation.
And a program calling its own analyzer is not automatically malformed.
Most importantly, you cannot exclude DD merely because its inclusion
would contradict your claim that HHH is a universal decider.
THAT IS THE VERY CLAIM UNDER EXAMINATION.--
The diagonal argument says:
ASSUME H IS TOTAL AND CORRECT.
Construct D using H.
Since H is total, its call returns.
Since H is correct, its answer must describe D's actual halting behavior.
But D deliberately does the opposite.
CONTRADICTION.
Your alternatives are:
- HHH loops while trying to analyze DD.
- HHH rejects DD as invalid.
In the first case, HHH is not total.
In the second, HHH is not a universal halting decider over valid program encodings.
NEITHER CASE REFUTES THE HALTING THEOREM.
Both are entirely consistent with it.
And your newly invented exception rCo
-a-a "EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER"
rCo is nothing more than an admission that your proposed decider cannot handle the diagonal construction.
THAT IS EXACTLY WHY A UNIVERSAL HALTING DECIDER CANNOT EXIST.
On 11/15/2026 2:14 PM, Python wrote:
Le 15/11/2026 |a 15:11, olcott a |-crit :
On 11/15/2026 5:37 AM, Python wrote:
Le 15/11/2026 |a 04:38, olcott a |-crit :
On 11/14/2026 11:02 AM, Python wrote:
Peter,
We have finally made some progress.
You explicitly concede:
-a-a-a "I will grant you that."
And:
-a-a-a "Yes I will grant you that."
In particular, you now acknowledge that static analysis can
establish termination WITHOUT executing every step of the program. >>>>>>
GOOD.
I knew that.
But then you write:
-a-a-a "These are all simply short cuts to reduce the
-a-a-a-a time that it takes to perform an actual simulation."
NO.
It is only behavior that is consistent with the behavior
of input I simulated by H that measures the behavior of
I AS AN INPUT TO H.
A mathematical proof of termination is not necessarily an
abbreviated simulation.
It can establish a property of ALL possible executions without
reconstructing ANY complete execution trace.
An input that takes no arguments eliminates the
Frederick Brooks (No Silver Bullet Essence and
Accidents of Software Engineering) inessential
complexity of an input with arguments.
You are confusing reasoning ABOUT a computation with PERFORMING
that computation.
-a-a-a "These short-cuts must remain consistent with
-a-a-a-a what the behavior of the simulation would be"
OF COURSE.
That is called CORRECTNESS.
Great we are back to mutual agreement.
DD simulated by HHH provides the ultimate basis of
the behavior that DD (AS AN INPUT) specifies to HHH.
Deciders apply finite string transformation /
inference steps to finite string inputs according
to a decision criteria.
It does not imply that the analysis must simulate the program.
Now to your latest escape hatch:
-a-a-a "Type mismatch error."
WHAT TYPE MISMATCH?
The halting problem concerns encoded programs and their inputs.
A hypothetical universal decider H accepts such encodings and
returns a Boolean answer.
The diagonal program D is itself a valid program.
Its encoding is a valid input to H.
And D calls H on that encoding.
THERE IS NO TYPE MISMATCH.
The type mismatch is the expectation that HHH
reports on the behavior of the executable
process DD() instead of the behavior that the
finite string (AS AN INPUT) specifies to HHH.
Here is the argument, stripped of every irrelevant implementation >>>>>> detail.
Assume H is total and correct.
Define D(x) as follows:
-a-a-a if H(x, x) says "halts":
-a-a-a-a-a-a-a loop forever
-a-a-a else:
-a-a-a-a-a-a-a halt
Now consider D(D).
If H(D, D) says "halts", D(D) does not halt.
If H(D, D) says "does not halt", D(D) halts.
CONTRADICTION.
// eliminate inessential argument to DD
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
08
09 void main()
10 {
11-a HHH(DD);
12 }
Simulation Trace
Line 11: main() invokes HHH(DD);
Line 03: DD calls HHH(DD); HHH simulates DD;
-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a Line 03: DD calls HHH(DD); HHH simulates DD;
-a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...
<snip>
Peter,
-a-a-a "The type mismatch is the expectation that HHH
-a-a-a-a reports on the behavior of the executable
-a-a-a-a process DD() instead of the behavior that the
-a-a-a-a finite string (AS AN INPUT) specifies to HHH."
THERE IS NO TYPE MISMATCH.
A program's encoding is a finite string.
That string describes a program.
The program has an operational semantics.
And the halting problem asks whether the computation described by
that encoding terminates.
It asks about the behavior of a machine that no
halt decider has direct access to.
The finite string encoding of the machine (as an input)
does specify the behavior of the static finite string
input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
otherwise it is a valid proxy for the behavior of the
underlying machine.
**Computation defined**
Turing equivalent Post canonical systems and semi-Thue
systems are simplified and made generic as follows:
All Turing equivalent computations can be reduced to
applying finite string transformation rules to finite
string inputs to derive any and all outputs.
Deciders only apply finite string transformation/inference
steps to their finite strings AS INPUTS.
They must only apply inference steps that are relevant
to the decision criterion.
Thus for halt deciders these inference steps are restricted
to the operational semantics of the language of computation
of the input.
THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.
You are inventing a distinction between the behavior of a program
and the behavior specified by its encoding.
Those are not two different decision problems.
Now consider your simulation trace:
-a-a-a main() calls HHH(DD)
-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...
YES, PETER.
YOUR HHH GETS STUCK IN INFINITE RECURSION.
CONGRATULATIONS.
YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.
There are at least two ways that this can be correctly understood:
(1) The behavior that the the input finite string DD
specifies to its halt decider HHH is non-halting behavior.
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
(2) When we hypothesize that HHH is applying a Prolog
unify_with_occurs_check() to its input the DD is rejected
as bad input. I report this one because it is exactly the
same process as unify_with_occurs_check(LP, not(true(LP))).
That is perfectly consistent with the Halting Theorem.
In fact, it is exactly the kind of failure the theorem tells us is
unavoidable for any proposed universal decider.
But the diagonal proof does not assume that H works by recursively
simulating its input.
IT ASSUMES THAT H IS TOTAL AND CORRECT.
Under that hypothesis, H(DD) returns an answer.
Therefore DD reaches its conditional branch.
And whichever answer H returns, DD does the opposite.
THAT IS THE CONTRADICTION.
You cannot refute a proof about ALL possible computable deciders by
exhibiting ONE PARTICULAR DECIDER THAT FAILS.
And your attempt to make the simulator's behavior the "ultimate
basis" of the program's semantics is circular.
A simulator is supposed to reproduce the semantics of the program.
THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.
The semantics is the operational semantics of C applied
to the decision criteria as inference steps.
If your simulator gets stuck, that tells us something about your
simulator.
It does not establish that the program is invalid.
Nor does it establish that a hypothetical total H could avoid the
diagonal contradiction.
Your entire argument amounts to:
"My implementation of H cannot decide D."
YES.
THAT IS WHAT THE HALTING THEOREM PREDICTS.
You have spent 28 years demonstrating an example of the theorem you
claim to have refuted.
Peter,
-a-a-a "The finite string encoding of the machine
-a-a-a-a does specify the behavior [...] EXCEPT WHEN
-a-a-a-a THE INPUT CALLS ITS OWN DECIDER"
THERE IT IS.
YOUR ENTIRE "REFUTATION" IN ONE SENTENCE.
You accept that program encodings describe program behavior.
That is not perfectly exactly what I said.
the nuances of detail are crucial.
Finite strings are incorrectly assumed to always be a
valid proxy for the behavior of the underlying computation.
They are NOT IN FACT ALWAYS SUCH A VALID PROXY.
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:49:29 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,582 |