Subject: Re: Correcting the errors in the foundation of computation --- Emil Post
On 10/28/2026 12:55 PM, Mike Terry wrote:
On 28/10/2026 00:07, Python wrote:
Le 27/10/2026 … 22:18, Andr‚ G. Isaak a ‚crit :
On 2026-10-27 11:40, olcott wrote:
On 10/27/2026 12:32 PM, Andr‚ G. Isaak wrote:
On 2026-10-27 10:57, olcott wrote:
On 10/27/2026 11:46 AM, Python wrote:
Fine, Peter. Call it "call" instead of "evaluate".
It changes absolutely nothing.
At line 03:
˙˙˙ int Halt_Status = HHH(DD);
control enters H1.
Now there are exactly two relevant possibilities:
˙˙˙ 1. H1 returns.
˙˙˙˙˙˙ Its return value becomes Halt_Status and DD continues.
˙˙˙ 2. H1 does not return.
˙˙˙˙˙˙ DD remains stuck at that call.
We agree on that much.
You claim (2) is categorically inevitable.
I am asking WHY.
HHH0 sees Step (1) has been met first.
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 }
(1) as soon as HHH sees that DD calls the same function
FROM THE SAME ADDRESS twice in sequence
(2) and there are no conditional branch instructions
from the beginning of DD until this call
(3) this matches the "infinite recursion" non-halting
behavior pattern
(4) proving that DD simulated by HHH cannot possibly
reach it own line 06
(5) thus satisfying the criterion measure of non-halting.
Putting aside the question of whether this pattern is actually a
non- halting pattern (Python has given you a counterexample
suggesting it is not which you simply dismissed as being outside
the domain of HHH), the problem is that this pattern isn't actually >>>>> met.
I never claimed to have made a universal halt decider.
I only claimed to show that HHH(DD)==0 is correct when
one carefully pays complete attention to this:
Whether you've claimed to have made a universal halt decider is
irrelevant to the fact that Python has provided an example which
calls into question whether your alleged 'infinite recursion' halting
pattern is actually a reliable diagnostic. If it isn't, you can't
claim it shows anything about DD()'s halting status
Axiom 1 --- Paraphrase of Emil Post definition of computation
All computations are equivalent to the application of finite
string transformation rules to finite string inputs to derive
any and all outputs.
This is not absolutely required yet is very helpful to see
exactly where the Halting Theorem violates Axiom 1
Nothing in the halting theorem violates the above. You're imposing
something else which is not actually stated in the above axiom and
which is not actually true; namely, that computations are restricted
to answering questions about finite strings. This does *not* follow
from your axiom.
Axiom 2
Deciders must apply finite string transformation inference
steps to their finite string inputs that are relevant to the
decision criteria and make their decision on this basis.
And this axiom is entirely pointless as far as I can tell. It
contributes nothing to the theory of computation.
Because the HHH() embedded within simulated DD() simulates
*conditionally*, there ARE conditional branch instructions between
the various simulation levels of DD() meaning that your criterion
No. 2 is not satisfied. You can't ignore those conditional branches >>>>> which is what your HHH does..
Andr‚
That is merely your lack of complete attention to this:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
˙˙˙˙ If simulating halt decider H correctly simulates its
˙˙˙˙ input D until H correctly determines that its simulated D
˙˙˙˙ would never stop running unless aborted then
You constantly repeat this phrase, but as has been pointed out to you
many times, Sipser agrees that IF a simulating halt decider CORRECTLY
determines that it's simulated input would never stop running unless
aborted then it is non halting. But you have failed to meet this
conditional. You haven't *correctly* determined that the input needs
to be aborted.
The reason you fail to see this is because you consistently
misinterpret what Sipser actually agreed to. Bear in mind that Sipser
has never looked at your actual code so he didn't see what you are
actually doing when he made this agreement.
Sipser is agreeing that if a simulated input would not halt unless
aborted by *the halt decider*, then you can conclude it is non halting.
The thing you fail to recognize is that in your example, you have a
function HHH() acts as a simulating halt decider *only* when it is
called directly. When HHH() is called from within simulated DD() it
is *not* the halt decider; it is simply an integral part of DD() and
thus part of the program under test, not part of the program
performing the testing. Anything that gets aborted by an invocation
of HHH() within simulated DD() does not count as being aborted by the
simulating halt decider. DD() is simply giving up on part of its
internal computations, and when it aborts something being run from
*inside* DD(), that's simply part of the normal operation of DD().
Remember that in the Linz proof, Linz's H-hat doesn't *call* his H;
it contains a modified copy of his H which is effectively an entirely
separate piece of code. By having DD() call HHH() you're obscuring
the separation between two entirely distinct programs: HHH() and
DD(). If you had stuck with Turing Machines instead of using C (a
language ill-suited for discussing computational theory) you wouldn't
have been able to do what you've done.
Your HHH() (the outermost one), claims that it needs to abort the
DD() which it simulates but this is simply false. The HHH() *inside*
of simulated DD(), which is not the simulating halt decider that
Sipser refers to, will eventually abort its input, at which point
simulated DD() would terminate normally had HHH() not prematurely
aborted it.
You need to keep these various instances of HHH() separate in your
mind and realise that only the outermost one constitutes the
simulating halt decider.
Your system is broken.
Andr‚
Exactly
This is the distinction Peter keeps erasing.
There are two different roles:
˙˙˙ HHH_outer simulates DD
and, as part of that simulation,
˙˙˙ DD calls HHH_inner
HHH_inner is now part of the computation being simulated. It cannot
both be treated as an ordinary call made by DD AND magically inherit
the authority of HHH_outer to abort the computation under test.
I don't recall PO claiming it can do that, but I don't read PO's posts
very much any more. (More likely I misunderstand what you're saying.)
Obviously, HHH_inner cannot magically abort HHH_outer's simulation of
which it's a part.˙ It could in principle abort it's own simulation of DD_inner (which calls HHH_inner_inner etc.) - EXCEPT...
...when HHH_inner is simulated specifically by HHH_outer, that
simulation [should] exactly track the computation steps of HHH_outer.
This implies that if HHH_inner had got to the point of aborting
DD_inner, HHH_outer would already have reached that computation point
and aborted HHH_inner. [Contradiction].˙ IOW HHH_inner is never
simulated as far as the point where it would abort anything.˙ [Because HHH_outer will have aborted it before it gets that far in the
computation. Other simulators like HHH_noabort don't have this issue]
PO frequently says something like "If you don't understand that DD
simulated by HHH cannot
possibly reach its own line 6 while being simulated by HHH then you
simply don't understand".˙ Note the PO-wording here:˙ "..line 6 *while
being simulated* by HHH..."˙˙ In the same way as HHH_inner is not
simulated [by HHH_outer] as far as its abort logic, its also the case
that it is never simulated [by HHH_outer] as far as its return
statement.˙ So IN THAT SENSE what PO says is correct, although he is incapable of simply explaining that point, if that is indeed what he means.
So is this actually what PO means [which would make it correct]?˙ I
don't know for sure!˙ Of course, if he does his argument is still wrong,
but for slightly different reasons, which I feel would be important for
you.˙ And of course, the definition of halting used in HP is that of the computation halting, not whether or not various simulations are
simulated as far as reaching a halt state. There is a whole world of PO- misunderstandings concerning computation/simulation/halting that you
have not really needed to bottom out so far.
Just to be clear, When DD is simulated by simulators other than HHH, it
can reach its line 6 provided HHH_inner aborts at some point, because
unlike HHH the simulator may simulate beyond the HHH abort point and see
it reach line 6.˙ [This thoroughly confuses PO, but I don't think
anybody can get him to think logically about this.˙ That's fine.]
BTW, the notation HHH_outer, HHH_inner, HHH_inner_inner... is not good. I've used HHH[0], HHH[1] etc. in the past where [n] indicates nested simulation level n.˙ So HHH[0] is directly executed HHH and so on.
That's worked well for me!˙ (Downside is that it needs to be explicitly explained.)
And the consequence is very simple.
If HHH_inner detects the recursion and returns 0, then simulated DD
continues:
˙˙˙ Halt_Status = 0
˙˙˙ if (Halt_Status) ...˙˙ // false
˙˙˙ return 0
So DD reaches line 06.
Except that never happens, DURING A SIMULATION PERFORMED BY HHH_outer,
as explained above. HHH_outer will always abort HHH_inner before it
would get to that point.˙ We may correctly point out that if the outer simulation were /continued/ in some way, the simulated DD would
eventually get to that point
Nope.
On 10/23/2026 3:54 AM, Python wrote:
Peter, I understand perfectly well what I agreed to.
I agreed that IF HHH keeps recursively simulating
the HHH call encountered at DD line 03, then we obtain:
HHH -> DD -> HHH -> DD -> ...
and that recursive simulation does not naturally return.
<begin>
Your own "does not naturally return" means HHH
does not reach its own "return" statement.
When HHH does not reach its own "return" statement
then DD never receives a value from HHH.
When DD never receives a value from HHH then
DD never reaches its own "return" statement.
When DD never reaches its own "return" statement
then the correctly simulated DD never stops running.
<end>
--
Copyright 2026 Olcott
Axiom 1 --- Paraphrase of Emil Post definition of computation
All computations are equivalent to the application of finite
string transformation rules to finite string inputs to derive
any and all outputs.
Axiom 2 --- Correcting the misnomer term-of-the-art: decider
Deciders must apply finite string transformation inference
steps to their finite string inputs that are relevant to the
decision criteria and make their decision on this basis.
*Succinct refutation of the Halting Theorem*
https://github.com/plolcott/x86utm/blob/master/README.md
The essence of computation is applying finite
string transformations to finite string inputs
to derive outputs. // paraphrase of Emil Post
My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable for the entire body of general knowledge.
The complete structure of this system is now defined.
The entire body of knowledge expressed in language is
comprised of two types