Re: HHH(DD) INcorrectly reject its input as non-halting --- VERIFIED FACT

On 6/12/25 11:34 AM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 It is a verified fact that DD() *is* one of the forms
of the counter-example input as such an input would
be encoded in C. Christopher Strachey wrote his in CPL.

First LIE.
TO BE that form of the counter example, DD needs to include as part of itself, a copy of the code of HHH, and thus make itself a PROGRAM.
SInce you stipulate that "the input" does not actually contain that codd, but it only exists in the same memory space, all you are doing is showing that:
First: your decider isn't just a function of its input, and thus fails to meet the model of a program.
Second: Since the code of HHH isn't part of the input. you can't "correctly simulate THE INPUT" as your simulation needs to use information that is not part of the input
Third, your HHH doesn't have a fully defined behavior (as your argument entails it having a number of different behaviors, each of which afffects the code assumed as part of the input) and thus even it isn't in line with the requirements of the proof program.
Note, in Strachey, the "input" isn't the CPL code of just the function D, but a reference to the FULL PROGRAM created by D.

 // rec routine P
//   §L :if T[P] go to L
//     Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243

ANd note, that passed the full definition of P to T as access to the decider to try to decide on, not just the function C as you claim yours does.

void Strachey_P()
{
   L: if (HHH(Strachey_P)) goto L;
   return;
}
 https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? redirectedFrom=fulltext

Note. that if you actually look at what was passed to HHH, it is an address in memory, which by itself doesn't actually define the program.
Thus, "the input" must be interpreted to include the code that PROGRAM uses. To try to define it to be just the code of the reference C funcition, means that HHH can not look anywhere else for details of the input, and thus can't simulate past the call instruction.

 It *is* a verified fact DD correctly simulated by HHH cannot
possibly reach its own "return" statement final halt state
because the input to HHH(DD) specifies recursive simulation.

But, per you stipulation, the code for HHH is not in the input, and thus HHH can not possible correctly simulate this input.
And, since to even talk about the behavior of this input, it needs to be a program, which since it uses a copy of the decider, means the decider must also be a program, and thus has fixed behavior.
Thus, if, as you claim, HHH correctly returns the value 0 as its answer, it does so for ALL copies of its input, and also by your argument, we know that HHH *MUST* have stoped its simulation before it got to the end of the simulation, and thus it is *NOT* a "correct simulation" and thus your claim is just sperious, as it is based on an non-exisdting condition.
In fact, since you have shown that when HHH and DD have had there category error fixed, that HHH(DD) returns 0, we can easily see that the actual correcct simulation of the input (which will match the requirement of the behavior of the program it represents) will reach its terminal state, as DD calls HHH(DD) which *WILL* after fintite time return 0, and thus DD will halt

 All of the above code is fully operational in this file
https://github.com/plolcott/x86utm/blob/master/Halt7.c
 

Which shows that when we do fix the decider and input by the code specified there, that it is a fact that HHH(DD) will return 0, and that the direct execution of DD() will halt, and thus HHH is wrong, and you are just shown to be a stupid and ignorant liar.
As per previous conversations, you have demonstracted that you accept these conclusions, as you have been unable to provide any counter to them, except the improper one of just repeating your error.
Thi shows that either you know that you are just intentionally lying, or are just so mentally challanged that you just don't understand the meaning of the words you use, or how logic works, or even that it means for something to be true.
This will be your eternal reputation, a man who was likely so stupid that he became a big pathological liar.