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 / C++ groups are the only people in the
world that did not flat out lie about this question:

Does DD simulated by HHH ever reach its own "return"
statement 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

The problem is not C, and nobody needs to lie about it.

Your question is loaded:

Does DD simulated by HHH ever reach its own return
statement WHILE DD IS BEING SIMULATED BY HHH?

If "while" means:

during the interval in which the recursive simulation
is still continuing

then of course DD has not yet returned DURING that interval.

That is a tautology, not a proof that the interval lasts forever.

If instead "while" means:

HHH continues simulating DD forever

then you have simply put the disputed conclusion into the question.

The actual question is:

CAN the HHH(DD) invoked at line 03 return 0?

If YES:

HHH(DD) returns 0
-> Halt_Status = 0
-> line 04 is false
-> line 05 is skipped
-> line 06 returns 0.

If NO, PROVE that it cannot return 0 without assuming that the recursive simulation continues forever.

That has always been the missing step.


And we have already demonstrated concretely why recognizing a repeated
call pattern is insufficient to prove infinite recursion.

I gave you this program:

typedef void (*fn)(unsigned);

void F(unsigned);
void G(unsigned);
void Done(unsigned);

void Done(unsigned n)
{
(void)n;
}

void G(unsigned n)
{
fn next[2] = { F, Done };
fn p = next[n];
p(n + 1);
}

void F(unsigned n)
{
G(n);
}

void P(void)
{
F(0);
}

Its execution is:

P
-> F(0)
-> G(0)
-> F(1)
-> G(1)
-> Done(2)
-> return
-> ...
-> halt

The same CALL instruction in F calls G twice.

Yet the computation halts, because the computational state is different.

And YOU reported the result of running your HHH on this input:

"My code did report 0 for non-halting on your input."

P demonstrably halts.

When that was pointed out, your answer was:

"Then it is simply outside the domain of HHH."

So we already have an actual example demonstrating the flaw in reasoning
from repeated control-flow structure to non-halting.

Your detector said non-halting.

The program halts.

You then excluded the counterexample from HHH's domain.

This makes the missing proof concerning DD even more important, not less.

You cannot replace:

I have observed another recursive call

with:

therefore there can never be a return.

For DD, you still need to establish:

HHH(DD) at line 03 CANNOT return 0.

Another nesting level does not establish that.
Ten nesting levels do not establish that.
Any finite recursive prefix does not establish that.

And "while the recursion continues, it continues" certainly does not
establish that it continues forever.

Calling everyone who refuses to accept that missing inference a liar does
not supply the inference.


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

On 11/1/2026 7:46 AM, Python wrote:

The problem is not C, and nobody needs to lie about it.

That you keep erasing the context of what you are
replying to IS DISHONEST

That you keep changing my words IS DISHONEST

The entire scope of my whole question is C.

I am only asking about what happens while DD
is being simulated by HHH.

I only want to get closure on my 22 year long
primary research from first principles.

I have 100,000-fold more persistence than
neurotypicals. I simplified my question so that
expert C programmers can easily answer it.

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 / C++ groups are the only people in the
world that did not flat out lie about this question:

Does DD simulated by HHH ever reach its own "return"
statement 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

On 11/1/2026 8:01 AM, dbush wrote:

On 11/1/2026 8:35 AM, olcott wrote:

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 / C++ groups are the only people in the
world that did not flat out lie about this question:

Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?

The above statement is unclear

counter-factual. The context only enables
HHH to be construed as a C interpreter of
a C function.

as "DD" and "HHH" could be referring to:

* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary set
of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the starting address of a C function.

So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.

To make the request for clarification more explicit:

Does [algorithm|C function|finite string] DD simulated by [algorithm|

C function|finite string] HHH ever reach its own "return"

statement while [algorithm|C function|finite string] DD is being

simulated by [algorithm|C function|finite string] HHH?

For each instance of "[algorithm|C function|finite string]" above, pick
one and give the resulting sentence.

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

On 11/1/2026 8:01 AM, dbush wrote:

On 11/1/2026 8:35 AM, olcott wrote:

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 / C++ groups are the only people in the
world that did not flat out lie about this question:

Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?

The above statement is unclear as "DD" and "HHH" could be referring to:

* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary set
of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the starting address of a C function.

So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.

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.

To make the request for clarification more explicit:

Does [algorithm|C function|finite string] DD simulated by [algorithm|

C function|finite string] HHH ever reach its own "return"

statement while [algorithm|C function|finite string] DD is being

simulated by [algorithm|C function|finite string] HHH?

For each instance of "[algorithm|C function|finite string]" above, pick
one and give the resulting sentence.

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

On 11/1/2026 9:50 AM, olcott wrote:

On 11/1/2026 8:01 AM, dbush wrote:

On 11/1/2026 8:35 AM, olcott wrote:

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 / C++ groups are the only people in the
world that did not flat out lie about this question:

Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?

The above statement is unclear as "DD" and "HHH" could be referring to:

* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary
set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.

So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.

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.

So would the following be correct?


Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C function HHH?

To make the request for clarification more explicit:

Does [algorithm|C function|finite string] DD simulated by

[algorithm| C function|finite string] HHH ever reach its own "return"

statement while [algorithm|C function|finite string] DD is being

simulated by [algorithm|C function|finite string] HHH?

For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.

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