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

On 6/5/25 12:33 AM, olcott wrote:

On 6/4/2025 10:41 PM, dbush wrote:

On 6/4/2025 11:32 PM, olcott wrote:

On 6/4/2025 9:56 PM, dbush wrote:

On 6/4/2025 10:44 PM, olcott wrote:

On 6/4/2025 9:13 PM, dbush wrote:

On 6/4/2025 10:09 PM, olcott wrote:

On 6/4/2025 8:43 PM, Richard Damon wrote:

On 6/4/25 11:50 AM, olcott wrote:

On 6/4/2025 2:04 AM, Mikko wrote:

On 2025-06-03 21:39:46 +0000, olcott said:
>

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

>
No, they don't say that. A halting decider (and a partial halting
decider when it reports) must report whether the direct execution
of the computation asked about terminates. Unless that computation
happens to be DDD() it must report about another behaviour instead
of DDD().
>

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

>
To say that nobody has noticed that is a lie. Perhaps they have not
mentioned what is irrelevant to whatever they said. In particular,
whether DDD() calls HHH(DDD) is irrelevant to the requirement that
a halting decider must report about a direct exection of the
computation the input specifies.
>

>
*People have ignored this for 90 years*
*People have ignored this for 90 years*
*People have ignored this for 90 years*
>
The only possible way that HHH can report on the
direct execution of DDD() is for HHH to report on
the behavior of its caller:

>
So?
>
It *IS* a fact that to be correct, it needs to answer about the direct executiom of the program that input represents.
>
That is DEFINITION.
>

>
Likewise with the definition of Russell's Paradox
until ZFC showed that this definition is complete
nonsense.
>

>
But unlike Russel's Paradox, which showed a contradiction in the axioms of naive set theory, there is no contradiction in the axioms of computation theory.  It follows from those axioms that no H exists that performs the below mapping, as you have *explicitly* agreed.
>

>
int main()
{
   DDD(); // comp theory does not allow HHH to
}        // report on the behavior of its caller.
>

>
>
int main()
{
    DDD();     // this
    HHH(DDD);  // is not the caller of this: this is }              // asking what the above will do

>
That is just not the way that computation actually works.

>
Sure it is.  We don't care how the mapping is generated, only that it is generated.
>

 There is not enough information in the input to
know how the caller works.

The the input isn't complete, and you did your problem wrong.
This is because you fundamentally have errors in your setup, errors that you even admit, showing your ignorance of the system.
First, HHH to be a decider, must be a "Compuation" (aka Program) which means it has a definitive mapping from each of its inputs, to the answer it will give. This is because its algorithm needs to be fully defined, as a sequence of deterministic and fully define steps. (Get the right answer isn't such a step).
Given that definition, if in the representation of DDD, we include a full representation of that HHH, then teh input DOES have enough information to fully define how that program works, as that input COULD be given to a UTM/Correct and complete simulator, that will determine whether this program will halt when it is run or not. Since you have stipulated that you HHH WILL BE a decider, we know that it will ALWAYS return, and thus will always at some point abort its emulation of the input.
Thus we can show that DDD will always be halting, and since your specifications say that HHH can only return Halting if it reaches the final state, and it can't do that, it will, by definition be incorrect for this sort of input.

 Also there is not enough information in any integer
to predict who the president will be.
 char* WhatIsTheNameOfThePresidentIn2030(int x);
  

Which just says that there isn't a mapping from Integers to Who will be president.
THere *IS* a mapping from COMPLETE representation of programs to whether they halt or not. That mapping just isn't computable, this come out of the existance of the UTM / Complete simulator, giving a basis for the definition of the correct answer for the decider.
Your problem is that it turns out one program can't be both, the complete simulator that defines the answer, and the decider that gives the answer in finite time.