Re: Incorrect requirements --- Computing the mapping from the input to HHH(DD)

On 5/9/25 12:04 PM, olcott wrote:

On 5/9/2025 4:14 AM, Fred. Zwarts wrote:

Op 09.mei.2025 om 04:13 schreef olcott:

On 5/8/2025 8:30 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:

On 5/8/2025 6:49 PM, Keith Thompson wrote:

olcott <polcott333@gmail.com> writes:
[...]

void DDD()
{
    HHH(DDD);
    return;
}
>
If you are a competent C programmer then you
know that DDD correctly simulated by HHH cannot
possibly each its own "return" instruction.

"cannot possibly each"?
I am a competent C programmer (and I don't believe you can make
the same claim).  I don't know what HHH is.  The name "HHH" tells
me nothing about what it's supposed to do.  Without knowing what
HHH is, I can't say much about your code (or is it pseudo-code?).
>

>
For the purpose of this discussion HHH is exactly
what I said it is. It correctly simulates DDD.

>
Does HHH correctly simulate DDD *and do nothing else*?
>
Does HHH correctly simulate *every* function whose address is passed
to it?  Must the passed function be one that takes no arguments
and does not return a value?
>
Can HHH just *call* the function whose address is passed to it?
If it's a correct simulation, there should be no difference between
calling the function and "correctly simulating" it.
>
My knowledge of C tells me nothing about *how* HHH might simulate
DDD.
>

>
HHH can only simulate a function that take no arguments
and has no return value. HHH also simulates the entire
chain of functions that this function calls. These can
take arguments or not and have return values or not.
>
Thus HHH ends up simulating itself (and everything
that HHH calls) simulating DDD in an infinite
sequence of recursive emulation until OOM error.
>

We need not know anything else about HHH to
know that DDD correctly simulated by HHH cannot
possibly REACH its own "return" instruction.

>
Assuming that HHH(DDD) "correctly simulates" DDD, and assuming it
does nothing else, your code would be equivalent to this:
>
     void DDD(void) {
         DDD();
         return;
     }
>

>
Exactly. None of these people on comp.theory could
get that even after three years.
>

Only if you forget that your proposed HHH aborts and returns.

 *This slight augmentation takes that into account*
 void DDD()
{
   HHH(DDD);
   return;
}
 When 1 or more statements of DDD are correctly
simulated by HHH then this correctly simulated
DDD cannot possibly reach its own “return statement”.
  

But it can't simulate past the call to HHH, as it doesn't have the code for that as part of its input.
And partial simulation not reaching a final state is not "Non-Halting".