Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/10/25 11:13 AM, olcott wrote:

On 5/10/2025 2:15 AM, Mikko wrote:

On 2025-05-09 03:01:40 +0000, olcott said:
>

On 5/8/2025 9:23 PM, Keith Thompson wrote:

Richard Damon <richard@damon-family.org> writes:

On 5/8/25 7:53 PM, olcott wrote:

[...]

void DDD()
{
  HHH(DDD);
  return;
}
We don't need to look at any of my code for me
to totally prove my point. For example when
the above DDD is correctly simulated by HHH
this simulated DDD cannot possibly reach its own
"return" instruction.

>
And thus not correctly simulatd.
>
Sorry, there is no "OS Exemption" to correct simulaiton;.

>
Perhaps I've missed something.  I don't see anything in the above that
implies that HHH does not correctly simulate DDD.  Richard, you've read
far more of olcott's posts than I have, so perhaps you can clarify.
>
If we assume that HHH correctly simulates DDD, then the above code is
equivalent to:
>
void DDD()
{
DDD();
return;
}
>
which is a trivial case of infinite recursion.  As far as I can tell,
assuming that DDD() is actually called at some point, neither the
outer execution of DDD nor the nested (simulated) execution of DDD
can reach the return statement.  Infinite recursion might either
cause a stack overflow and a probable program crash, or an unending
loop if the compiler implements tail call optimization.
>
I see no contradiction, just an uninteresting case of infinite
recursion, something that's well understood by anyone with a
reasonable level of programming experience.  (And it has nothing to
do with the halting problem as far as I can tell, though of course
olcott has discussed the halting problem elsewhere.)
>
Richard, what am I missing?
>

*****
Now you are seeing what I was talking about.
Now you are seeing why I needed to cross post
to comp.lang.c

>
What were you told in comp.lang.c that you were not told in comp.theory?
>

 void DDD()
{
   HHH(DDD);
   return;
}
 People quickly realize that when DDD is correctly
simulated by HHH that DDD cannot possibly reach
its "return" statement (final halt state).

But you are just showing your stupidity, as your DDD is IMPOSSIBLE to correcctly emulate, as what you define as the repesentation of DDD, amd your own descirption of it, excludes the code for HHH, so you can not use that, and thus it just doesn't HAVE behavior beyond the call instruction, is it just isn't a program to HAVE behavior.
Until you actually define that HHH has been added as part of the DDD in the input to make it actually be a program, it just can not be "correctly emulated"
Of course, once you do that, every different pairing of DDD to an HHH is a different input, and thus none of your HHH's are paired to the same DDD, so you can't translate behavior from one DDD/HHH pair to another.

 Once you know this then you can see that the
same thing applies to DD.

Right, it isn't a program either, not until you ADD the code of HHH to it, and thus each HHH gets a different DD/HHH pairing,

 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 Once you know this then you know that the halting
problem's otherwise "impossible" input is non-halting.

Nope. Just that you are showing yourself to be non-thinking.
Your HHH can not correctly emulate an input that is not actualy the representation of a program.

 Once you know this then you know that the halting
problem proof has been correctly refuted.
 

Nope, just that you have proved yourself to be a liar.