Re: My reviewers think that halt deciders must report on the behavior of their caller

On 6/3/25 5:39 PM, olcott wrote:

They all say that HHH must report on the behavior of
direct execution of DDD()

Right, that is the DEFINITION.

 yet never bother to notice
that the directly executed DDD() is the caller of HHH(DDD).

So? That *IS* what the input represent for THIS call.

 void DDD()
{
   HHH(DDD); // When DDD calls HHH(DDD) this HHH is not
   return;   // accountable for the behavior of its caller
}

No, it is accountable for the program that its input represent, whether or not it happens to be its caller.
Of course, that also means the input need to include the WHOLE program, which includes the code for the PROGRAM HHH, which has to have been defined.

 On the other hand HHH(DDD) is accountable for the
behavior that its actual input actually specifies.

Right, which is the behavior of the program that its input repreesent.

 HHH(DDD) simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)...

If that is what you are defining HHH to be, then it never answers.
OF course, that *ISN'T* how you have actully defined HHH to be, but just what you IMAGINE HHH to be, even though that is NOT what the code of HHH does.

 <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its
     input D until H correctly determines that its simulated D
     *would never stop running unless aborted* then
 

Right, but it is does abort, then the above isn't what happens, as the ... doesn't happen, but the behavior will be:
HHH(DDD) simulated DDD that calls HHH(DDD), and the first HHH will simulate this until it THINKS that this program will not halt, and then it will abort its simulation and return 0 to what ever its caller.
This means that the direct execution, or the correct simulation of DDD will go as:
DDD calls HHH(DDD) which will simulate DDD until it thinks that this program will not halt, and then it will abort its simulation and return 0 to DDD which will then halt.
Thus DDD is not halting, and the decision that HHH made was wrong, and not based on a correct detemination that the input would not halt, and the input that we showed above did not halt was one that called a DIFFERENT program (also deceptively called HHH) that doesn't abort.
So, you are just proven to be a stupid liar that doesn't understand what programs are, and thinks that two different programs can be the same program.
And that your idea of "logic" is based on lying about what you are doing. This shows that your basic nature is that of a liar, which is why you are destined for that lake of fire, unless you repent and stop lying.