Re: No decider is ever accountable for the behavior of the computation that itself is contained within

Op 26.jul.2024 om 18:28 schreef olcott:

No decider is ever accountable for the behavior of the
computation that itself is contained within.
 It is only accountable for computing the mapping from the
input finite string to the actual behavior that this finite
string specifies.
 typedef void (*ptr)();
int HHH(ptr P);
 void DDD()
{
   HHH(DDD);
}
 int main()
{
   DDD();
}

You keep repeating this, without learning from your errors.
DDD is a misleading and unneeded complication. It is easy to eliminate DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. This proves that the problem is not in DDD, but in HHH, which halts when it aborts the simulation, but it decides that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.
No matter how much olcott wants it to be correct, or how many times olcott repeats that it is correct, it does not change the fact that such a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end confirms it. The trace he has shown also proves that HHH cannot reach the end of its own simulation. So, his own claims prove that it is true that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.

 HHH(DDD) is only accountable for the actual behavior that
its input specifies and is not accountable for the behavior
of the computation that itself is contained within:
the directly executed DDD();

And the input is DDD, which calls HHH, so HHH is accountable for a correct simulation of *itself*.
If it recognises that a copy of itself is within the input, it should take its own behaviour into account.
DDD has no other behaviour than HHH. When HHH returns, DDD does, too.
But HHH cannot possibly simulate *itself* correctly.