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

On 09/05/2025 23:18, olcott wrote:

On 5/9/2025 4:40 PM, Richard Heathfield wrote:

On 09/05/2025 21:15, olcott wrote:

On 5/9/2025 3:07 PM, Richard Heathfield wrote:

On 09/05/2025 20:46, olcott wrote:

We have not begun to get into any of those points.
We are only asking can DDD correctly simulated
by any HHH that can exist ever reach its own
"return" instruction.

>
DDD can't be correctly simulated by itself (which is effectively what you're trying to do when you fire up the simulation from inside DDD).
>

>
How the Hell did you twist my words to say that?

>
I haven't touched your words. What I have done is to observe that DDD's /only/ action is to call a simulator. Since DDD isn't itself a simulator, there is nothing to simulate except a call to a simulator.
>
It's recursion without a base case - a rookie error.
>
HHH cannot successfully complete its task, because it never regains control after the first recursion. To return, it must abort the simulation, which means the simulation fails.
>

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

>
On what grounds can you persuade an extraordinarily sceptical readership that HHH 'correctly simulated' DDD?
>

 Any competent C programmer can see that
the call from DDD to HHH(DDD) (its own simulator)
is equivalent to infinite recursion.

Sheer bluster.

On 5/8/2025 8:30 PM, Keith Thompson wrote:
 > 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;
 >      }
 >
 > Then the return statement (which is unnecessary anyway) will never be
 > reached.

I just wrote:
 >> HHH cannot successfully complete its task, because it never
 >> regains control after the first recursion.
Keith wrote:

In practice, the program will likely crash due to a stack
 > overflow, unless the compiler implements tail-call optimization, in
 > which case the program might just run forever -- which also means the
 > unnecessary return statement will never be reached.

Keith and I are in complete agreement.
You, on the other describe abject failure as 'correctly simulated'. There's nothing correct about it.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within