Re: Every sufficiently competent C programmer knows

On 3/11/25 9:26 AM, olcott wrote:

On 3/11/2025 5:01 AM, Richard Heathfield wrote:

On 11/03/2025 08:55, Fred. Zwarts wrote:

Op 11.mrt.2025 om 00:41 schreef olcott:

typedef void (*ptr)();
int HHH(ptr P);
>
void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}
>
void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}
>
void DDD()
{
   HHH(DDD);
   return;
}
>
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
That when HHH correctly emulates N steps of the
above functions that none of these functions can
possibly reach their own "return" instruction
and terminate normally.

>

>
Since HHH does see that same pattern that competent
C programmers see it correctly aborts its emulation
and rejects these inputs as non terminating.

>
All competent C programmers see that HHH correctly reports that it cannot possibly reach the 'return' instruction.

>
First, my credentials. I've been programming in C for over 35 years; I'm told that my book on C has been used on two undergraduate Comp Sci courses (one in the States and one in the UK); and I have my Knuth cheque. I don't claim to be any kind of programming guru, but I hope I do not overstate the case when I suggest that I can be regarded as competent not just as a programmer but specifically in the C language.
>
And yet I can't even /see/ HHH, let alone judge what it does or does not do correctly. All I see is a call to it.
>

 It is stipulated that HHH correctly emulates N
steps of the x86 machine code of its input functions.
This may or may not include HHH emulating itself
emulating an input.

And thus you have stipulated that all calls to HHH will return in finite time, as it only take finite time to emulate a finite number of instructions.
Thus HHH must, to do that, must treat the call to HHH(DD) within DD as returning a value, and since you claim it is correct to return 0, obviously that number is 0, and thus it is OBVIOUS, that DD correctly emulated to call an HHH(DD) that WILL return 0, must reach its final halting state,
If it stops before it gets there, because it only emulates N steps, that doesn't mean that the behavior of the input is non-halting, as that requires it to NEVER reach a final state no matter how long you process the input.

 

And ld concurs. It can't see HHH either.
>
I suggest that Mr Olcott should supply the missing source code if he wishes to be taken seriously.
>

 Not required for the above thought experience where
every relevant behavior has been fully specified. This
is merely another lame attempt on your part to perpetually
dodge the point.
 

THen we just need to use the fact that HHH is claimed to return the answer.
You don't seem to understand that you can't depend on the Truth Fairy.
DD, by your definitions, HALTS, it just takes longer than HHH will look, and thus HHH gets the wrong answer.
Since you can't show why HHH needs to get to the end in its simulation, you are admitting that part of the requirement is just part of your FRAUD.