From Newsgroup: comp.theory

On 10/3/2026 10:24 AM, Python wrote:

Le 03/10/2026 à 17:06, olcott a écrit :

On 10/3/2026 9:46 AM, Python wrote:

OK Peter. Here is my understanding of your argument. I am
deliberately not rebutting it yet.

You distinguish two things:

1. HHH receives DD as a finite string.

2. HHH may manipulate that finite string only according to finite
transformation rules corresponding to the operational semantics of C.

3. You distinguish what HHH can derive from DD in this way from what
happens when DD is actually called directly from main().

4. Your claim is that no valid finite sequence of transformations
performed by HHH on its input DD can derive the behavior of that
direct execution.

5. Therefore, requiring HHH to answer according to what DD would do
when directly executed from main() requires HHH to determine
something that cannot be obtained by the finite-string
transformations available to it.

6. You regard that requirement, rather than anything HHH actually
computes from its finite input, as the invalid step in the
conventional halting proof.

7. Hence your claim is not merely "HHH cannot decide whether DD
halts." Your stronger claim is that the conventional proof
illegitimately requires HHH to report a fact about a distinct direct
execution whose behavior cannot be derived by the permitted finite-
string transformation process.

I think that is the distinction you believe I previously missed.

If any part of 1-7 misrepresents your position, please identify the
number and correct it.

If you agree that 1-7 accurately states your argument, then we have
isolated the disagreement precisely and can examine whether step 4 is
actually true.

That is a 100-fold better understanding of my work than
any other human has ever presented. It even much more
succinctly presents my view much better than the best LLM.

Then let's keep those seven points as the agreed description of your position.

That is useful because it means we no longer have to argue about whether
I understand what you are claiming.

And I agree that your actual claim is more subtle than simply saying
that HHH somehow "solves the halting problem".

Your claim, as I now understand it, is specifically that the
conventional diagonal argument asks HHH to report the behavior of a computation distinct from the finite-string computation that HHH can actually derive from its input DD.

So let's focus entirely on point 4:

   No valid finite sequence of transformations performed
   by HHH on its input DD can derive the behavior of the
   direct execution of DD from main().

That is now the precise proposition we disagree about.

And I think we can examine that proposition without misrepresenting your position and without appealing to authority on either side.

We finally have a sharply defined question.

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);

keeps repeating unless aborted
Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()

Simulation invariant
DD correctly simulated by HHH cannot possibly reach past its own line 03

Concretely show DD simulated by HHH according to the
operational semantics of C such that this simulated DD
reaches its own line 06.
--
Copyright 2026 Olcott

*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 of relations between finite strings:
(a) *Axioms* Expressions of language that are stipulated to be true.

My system bridges the analytic/synthetic distinction by
expressly encoding all empirical "atomic facts" in a formal
language such as CycL of the Cyc project.

(b) *Inference Rules* Expressions of language that are semantically
entailed syntactically from (a) and/or (b).
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Peter,

You have gone back to a message from October 3, before we spent weeks isolating exactly what is wrong with this argument.

And now you ask:

Concretely show DD simulated by HHH according to the
operational semantics of C such that this simulated DD
reaches its own line 06.

Certainly.

You claim that:

HHH(DD) returns 0.

So correctly simulate THAT HHH inside DD:

03 Halt_Status = HHH(DD);

The simulated HHH(DD) behaves as you claim HHH(DD) behaves:

HHH(DD) returns 0.

Therefore:

Halt_Status = 0;

Continue the C operational semantics:

04 if (Halt_Status)

becomes:

if (0)

so line 05 is skipped and execution reaches:

06 return Halt_Status;

DD reaches line 06.

There. Done.

Your response will presumably be:

"But the simulated HHH(DD) does not return 0.
It recursively simulates DD instead."

And THAT is exactly the problem we have spent weeks identifying.

You simultaneously claim:

actual HHH(DD) returns 0

while your allegedly correct simulation of:

HHH(DD)

does NOT return 0.

Then your simulation is not simulating the behavior of the HHH you claim
to have implemented.

You cannot have both:

HHH(DD) returns 0

and:

a correct simulation of HHH(DD) cannot return 0.

Pick one.

If simulated HHH faithfully reproduces your claimed HHH:

HHH(DD) -> 0
DD -> line 06
DD halts
therefore 0 was wrong.

If simulated HHH instead recursively expands forever:

HHH(DD) does not return

then you have not simulated the terminating HHH(DD) that you claim returns
0.

And if you abort that recursive simulation and return 0 only to main, we
are straight back to the point you refused to answer yesterday:

you returned 0 to main,
not to the HHH call inside DD.

So please do not drag the discussion back to October 3 as though the intervening discussion never happened.

Your "simulation invariant":

DD correctly simulated by HHH cannot possibly
reach past its own line 03

already assumes the very thing at issue:

the HHH called at line 03 never returns.

But your claimed result is:

HHH(DD) returns 0.

Those two claims are incompatible if this is genuinely the same HHH
operating on the same DD.

That is the contradiction you keep calling a refutation of the Halting Theorem.

It isn't.

It is the Halting Theorem biting your implementation.
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/22/26 6:45 AM, Python wrote:

Peter,

You have gone back to a message from October 3, before we spent weeks isolating exactly what is wrong with this argument.

And now you ask:

Concretely show DD simulated by HHH according to the
operational semantics of C such that this simulated DD
reaches its own line 06.

Certainly.

You claim that:

   HHH(DD) returns 0.

So correctly simulate THAT HHH inside DD:

   03  Halt_Status = HHH(DD);

The simulated HHH(DD) behaves as you claim HHH(DD) behaves:

   HHH(DD) returns 0.

Therefore:

   Halt_Status = 0;

Continue the C operational semantics:

   04  if (Halt_Status)

becomes:

   if (0)

so line 05 is skipped and execution reaches:

   06  return Halt_Status;

DD reaches line 06.

There. Done.

Your response will presumably be:

   "But the simulated HHH(DD) does not return 0.
    It recursively simulates DD instead."

And THAT is exactly the problem we have spent weeks identifying.

You simultaneously claim:

   actual HHH(DD) returns 0

while your allegedly correct simulation of:

   HHH(DD)

does NOT return 0.

Then your simulation is not simulating the behavior of the HHH you claim
to have implemented.

You cannot have both:

   HHH(DD) returns 0

and:

   a correct simulation of HHH(DD) cannot return 0.

Pick one.

If simulated HHH faithfully reproduces your claimed HHH:

   HHH(DD) -> 0
   DD -> line 06
   DD halts
   therefore 0 was wrong.

If simulated HHH instead recursively expands forever:

   HHH(DD) does not return

then you have not simulated the terminating HHH(DD) that you claim
returns 0.

And if you abort that recursive simulation and return 0 only to main, we
are straight back to the point you refused to answer yesterday:

   you returned 0 to main,
   not to the HHH call inside DD.

So please do not drag the discussion back to October 3 as though the intervening discussion never happened.

Your "simulation invariant":

   DD correctly simulated by HHH cannot possibly
   reach past its own line 03

already assumes the very thing at issue:

   the HHH called at line 03 never returns.

But your claimed result is:

   HHH(DD) returns 0.

Those two claims are incompatible if this is genuinely the same HHH operating on the same DD.

you add urself to the endless list of those who have pointed out this particularly egregious incoherency

That is the contradiction you keep calling a refutation of the Halting Theorem.

It isn't.

It is the Halting Theorem biting your implementation.

--
arising us out of the computing dark ages,
please excuse my pseudo-pyscript,
~ the lil crank that could

--- Synchronet 3.22a-Linux NewsLink 1.2