DD is to be construed as a finite string of C source code of
a C function. HHH is to be construed as a C interpreter that
simulates C source code. HHH can simulate itself simulating
DD if needed.

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 }

*the C portion of my halting theorem refutation*
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.

*ENTAILS next step*

This mathematical induction proof of non-termination
simulation invariant:

*DD simulated by HHH does not halt while being simulated*

as formal proof of non-termination of DD while DD is being
simulated by HHH.


--
Copyright 2026 Olcott

Computation(Olcott)
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.

Because Post canonical systems are Turing-equivalent, anything
that cannot be derived by applying finite string transformations
to finite strings is outside the scope of Church?Turing computation.

Decider(Olcott)
Correcting the misnomer term-of-the-art: decider
Every Decider(Olcott) must apply finite string transformation
inference steps to their finite string inputs that are relevant
to the decision criteria. It must make its decision on this basis.

Halt Decider(Olcott)
Decider(Olcott) entails that Halt Decider(Olcott) H(D) must apply
finite-string inference steps according to the operational semantics
of the source-code computation language of D. The only way to determine
the halting property of a finite string input is to examine the same
beha

Le 01/11/2026 … 23:54, olcott a ‚crit :

DD is to be construed as a finite string of C source code of
a C function. HHH is to be construed as a C interpreter that
simulates C source code. HHH can simulate itself simulating
DD if needed.

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 }

*the C portion of my halting theorem refutation*
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.

*ENTAILS next step*

This mathematical induction proof of non-termination
simulation invariant:

*DD simulated by HHH does not halt while being simulated*

as formal proof of non-termination of DD while DD is being
simulated by HHH.

Peter,

WARNING: do NOT claim that anyone agreed with that "ENTAILS".

They did not.

They agreed with the preceding C proposition. Your alleged entailment is
YOUR next claim, and it has NOT been established.

Writing:

*ENTAILS next step*

does not prove an entailment.

And if you now cite dbush, dart200, me, or Sipser as agreeing with that
next step, you will be knowingly misrepresenting what we agreed to.

This is precisely the habit you have demonstrated for years: obtain
agreement to A, silently add YOUR A => B, then advertise the result as agreement with B.

You have now been warned explicitly, repeatedly, and in advance.

Do it again and you cannot plausibly call it a misunderstanding.


--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

On 11/1/2026 4:54 PM, olcott wrote:

DD is to be construed as a finite string of C source code of
a C function. HHH is to be construed as a C interpreter that
simulates C source code. HHH can simulate itself simulating
DD if needed.

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 }

*the C portion of my halting theorem refutation*
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.

When we already know that halting is defined as reaching
a final state and that the "return" statement of DD is
its final state then from this we know

*ENTAILS next step*

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 halts
in any N finite number of steps.

--
Copyright 2026 Olcott

Computation(Olcott)
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.

Because Post canonical systems are Turing-equivalent, anything
that cannot be derived by applying finite string transformations
to finite strings is outside the scope of Church?Turing computation.

Decider(Olcott)
Correcting the misnomer term-of-the-art: decider
Every Decider(Olcott) must apply finite string transformation
inference steps to their finite string inputs that are relevant
to the decision criteria. It must make its decision on this basis.

Halt Decider(Olcott)
Decider(Olcott) entails that Halt Decider(Olcott) H(D) must apply
finite-string inference steps according to the operational semantics
of the source-code computation language of D. The only way to determine
the halting property of a finite string input is to examine the same
beha

THAT implication is trivial.

You have:

A: simulated DD does not reach its final state
in any finite number of steps.

Then you define "halts" as reaching a final state and obtain:

B: simulated DD does not halt
in any finite number of steps.

So:

A => B

Fine. AGREED.

And you have STILL advanced ZERO steps toward refuting the Halting
Theorem.

You have merely replaced:

"does not reach its final state"

with:

"does not halt".

Now comes the ACTUAL problem:

Does HHH(DD) return 0, return 1, or not return?

0 -> DD halts.
1 -> DD loops.
no return -> HHH is not a terminating halt decider.

THAT is the wall your argument has been smashing into for 22 years.

Renaming "does not reach its final state" as "does not halt" does not get
you through it.


--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)