Re: Every HHH(DDD) is correct to reject its input

On 6/6/25 12:33 PM, olcott wrote:

On 6/6/2025 3:51 AM, Mikko wrote:

On 2025-06-05 16:01:46 +0000, olcott said:
>

On 6/5/2025 2:42 AM, Mikko wrote:

On 2025-06-04 15:00:07 +0000, olcott said:
>

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

On 2025-06-02 05:12:26 +0000, olcott said:
>

On 6/1/2025 6:20 AM, Mikko wrote:

On 2025-05-31 19:21:10 +0000, olcott said:
>

On 5/31/2025 2:11 PM, Mr Flibble wrote:

Olcott is doing this:
>
int main()
{
DDD(); // DDD calls HHH
}
>
This is incorrect as it is a category (type) error in the form of
conflation of the EXECUTION of DDD with the SIMULATION of DDD: to
completely and correctly simulate/analyse DDD there must be no execution
of DDD prior to the simulation of DDD.
>
Olcott should be doing this:
>
int main()
{
HHH(DDD);
}

>
I would have left it there except that many dozens of
reviewers have pointed out that they believe that HHH
is supposed to report on the behavior of its caller.

>
A halt decider is required to report on the computation it is asked
about. There is no requirement that a halt decider knows or can find
out whether it is called by the program about which is required to
report. Consequently, whether the computaton asked about calls the
decider is irrelevant.

>
void DDD()
{
   HHH(DDD);
   return;
}
>
The *input* to simulating termination analyzer HHH(DDD)
specifies recursive simulation that can never reach its
*simulated "return" instruction final halt state*

>
If it does then the "input" is not DDD, which specifies a halting
behaviour if HHH is a decider.

>
You can say these things only by making
sure to ignore the verified facts.

>
We can ignore irrelevant facts. But if you ignore relevant requirements
you can't prove that your soliution is correct.

>
As long as DDD emulated by HHH cannot possibly reach
its own "return" instruction final halt state then
DDD is non halting even if it is never simulated.

>
That is not what "non halting" means. If it can be exectuted to its
final halt state it is a halting computation, and we know that it
can be because it has been.
>

 We cannot simply ignore and thus give up on the case
where an input calls its own termination analyzer,
even if it is the historical precedent to give up.

The historical precedent wasn't "to give up" but to show that it is logically impossible for a correct halt decider to exist, in part because one of the allowed inputs is based on a program that calls a copy of the decider, and then does the opposite.

 void DDD()
{
   HHH(DDD);
   return;
}
 int main()
{
   DDD(); // The HHH(DDD) that DDD calls is not allowed
}        // to report on the behavior of its caller
 HHH(DDD) is, however, required to report on the behavior
that its input actually specifies.

Which *IS* the behavior of the program its input repesents, which *IS* the behavior of its caller in this case.

 DDD emulated by HHH according to the rules of the x86 language
is the only correct way to determine the actual behavior that
the input to HHH(DDD) actually specifies. This does include HHH
emulating itself emulating DDD.

But only if HHH actually does that. Otherwise, it is just the behavior of the input code DDD as correctly and completely emulated according to the rules of the x86 language, which will be (for a given input) a fixed behavior reguardless of which "correctd simulation" is used, as it doesn't depend on anything not part of that input.

 *The input to HHH(DDD) specifies*
HHH emulates DDD that calls a simulated HHH(DDD)
that simulates DDD that calls a simulated HHH(DDD)
that simulates DDD that calls a simulated HHH(DDD)
that simulates DDD that calls a simulated HHH(DDD)
that simulates DDD that calls a simulated HHH(DDD)
that simulates DDD that calls a simulated HHH(DDD)...
 

WHich means that if HHH follows your requirements, it just fails to be a decider and never answers.
If you try to say that it gets to break the simulation, then it no longer is the source of truth about the behavior of its input, but what the actual correct and complete simulation of the input program would do.
Note, this DOES require fixing the input to be the representation of a program, and thus includes the needed copy of the code of the PROGRAM HHH, which thus must be fixed into its behavior.
So, once you assert that HHH is a decider, and WILL (because it is allowed to) abort is simulation, and thus loses the power to be the arbiter of the behavior of its input, that such an input, when correctly simulated will halt, as the first level simulaed HHH will do exactly the same thing as HHH did, and will also abort its simulation, return 0 to DDD which will then halt.
The fact that you keep repeating your LIES just shows how little you care about what is true.