Re: Every sufficiently competent C programmer knows

On 3/11/2025 3:49 PM, Richard Heathfield wrote:

On 11/03/2025 19:32, wij wrote:

On Tue, 2025-03-11 at 19:06 +0000, Richard Heathfield wrote:

On 11/03/2025 18:33, wij wrote:

On Tue, 2025-03-11 at 18:23 +0000, Richard Heathfield wrote:

On 11/03/2025 17:42, Mike Terry wrote:

Finally, if you really want to see the actual HHH code, its in
the halt7.c file (along with DDD) that PO provides links to from
time to time.  However it's not very illuminating due to
bugs/design errors/misunderstandings which only serve to
obfuscate PO's errors in thinking.

>
[I've now seen the code. Oh deary deary me.]
>
Thank you for a spirited attempt to be cogent - or at least as
cogent as it is possible to be in the circumstances!
>
I think PO's first step must be to demonstrate that HHH()
correctly diagnoses some easy functions, such as these:
>
int rha(unsigned int i)
{
     while(--i > 0)while(--i > 0);
     return 0;
}
>
int rhb(unsigned int i)
{
     if(i > 0)
     {
       rhb(i/10);
     }
     return putchar(i + '0');
}
>
int rhc(unsigned int i)
{
     typedef int(*pf)(unsigned int);
     pf arr[3] = {rha, rhb, rhc};
     return arr[i % 3];
}
>
and other such obvious tests.
>
HHH(), the procedure that decides whether a program halts, is
required to work for all programs and all inputs. Does it work on
those cited above? I'm guessing it doesn't.
>

>
No TM can simulate itself.

>
It doesn't have to. For a start, it can take source code as input
and analyse it in much the same way that a compiler does.

>
SO, what is 'it', the decider?

 Yes. `It' is the program that determines whether an input program (fed in at runtime) will halt when supplied with data also fed in at run time.
 

(note: its input is the source of itself)

 No. Its input is /any/ program. Yes, it must be able to handle itself (or its own source, if it works on source code), but a decider that can only handle itself is trivial to write, and it doesn't even have to read the source:
 int halts(struct source *s)
{
   return 1;
}
 Gee, that was hard. But it doesn't address the Halting Problem. A general decider is required, and HHH() isn't one.
 

PO doesn't understand that this DD:
int HHH(uintptr_t *p)
{
     /* simulator that simulates for some amount of time, then stops and returns 0 */
}
int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
Is not the same as this DD:
int HHH(uintptr_t *p)
{
     /* unconditional simulator */
}
int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
He thinks he is free to imagine different implementations of HHH, not understanding that doing so changes the program being reported on.
On 2/22/2025 1:02 PM, olcott wrote:
 > On 2/22/2025 11:10 AM, dbush wrote:
 >> On 2/22/2025 11:43 AM, olcott wrote:
 >>> The first point is DD correctly simulated by HHH cannot
 >>> possibly terminate normally by reaching its own "return"
 >>> instruction.
 >>
 >> In other words, if the code of HHH is replaced with an unconditional simulator then it can be shown that DD is non-halting and therefore HHH(DD)==0 is correct.
 >>
 >
 > Wow finally someone that totally gets it.
He's got posts going back over 20 years in this newsgroup claiming he's refuted proofs of the halting problem, when of course he doesn't even understand the question.  He's demonstrated that he doesn't understand proof by contradiction 50 years after learning it.