Re: Analysis of Flibble’s Latest: Detecting vs. Simulating Infinite Recursion ZFC

Op 27.mei.2025 om 11:24 schreef Richard Heathfield:

On 27/05/2025 09:48, Fred. Zwarts wrote:

Op 26.mei.2025 om 22:28 schreef Richard Heathfield:

On 26/05/2025 20:35, Fred. Zwarts wrote:

Now DDD is not the caller of HHH

>
Yes, it is.
>
void DDD()
{
   HHH(DDD);
   return;
}
>

>
Only if we confuse levels of simulation.

 Only if we confuse terminology.
 Noun
 caller (plural callers)
      (telephony) The person who makes a telephone call.
A visitor.
     a gentleman caller
(bingo) The person who stands at the front of the hall and announces the numbers.
(programming) A function that calls another (the callee).
  DDD calls HHH. Therefore DDD is the caller of HHH.
 

  int main () {
    HHH(DDD);
  }
>
Here main is the caller of HHH.

 Yes.
 void DDD()
{
    HHH(DDD);
    return;
}
 Here DDD is the caller of HHH.
 HHH has (at least) two callers.
 

In the first level of simulation DDD is simulated and calls HHH, which could cause a second level of simulation, where DDD is the caller, but that does not happen, because the first HHH aborts the simulation at that point. At the first (and only level), DDD is not the caller of HHH. DDD is only the input to HHH, not the caller. HHH should decide about its input, not about its caller.
DDD is, in fact, a pointer to memory. This memory includes the code of DDD and all other code used by DDD, including the HHH that aborts. So, the input specifies a halting program. But HHH does not see that part of the specification, but aborts and makes the false assumption about itself that it does not halt. This bug in HHH does not change the verifiable fact that the input (not the caller) specifies a halting program.

 Understood, but you are only describing half the picture.
 We can observe DDD's behaviour directly by calling it directly:
 int main(void)
{
   DDD();
}
 Clearly this cannot change anything, because for simulation to be a valid technique simulation must give the same result as direct execution, and therefore direct execution must give the same result as simulation.
 Here, it is even more abundantly clear than ever that DDD is the caller of HHH. Since (according to Olcott) HHH cannot report on its caller, it cannot report on DDD.
 

Of course HHH can be called by any other function even by DDD. But that is completely irrelevant in the case where HHH is executed directly. In particular the case that we are discussing, where DDD is not executed directly.
   int main () {
     HHH(DDD);
   }
The simulation does not even arrive at the point where HHH is called by DDD, because it is aborted before the call is simulated. Nobody ever claimed that HHH must decide about its caller. HHH must decide about its input not about its caller. Even when it happens that the code of the caller is included in the input. I think we agree on that.