Re: HHH(DD) does correctly reject its input as non-halting --- VERIFIED FACT +++

On 6/15/25 10:51 AM, olcott wrote:

On 6/15/2025 4:23 AM, Mikko wrote:

On 2025-06-14 13:53:01 +0000, olcott said:
>

On 6/14/2025 6:30 AM, Mikko wrote:

On 2025-06-13 15:22:04 +0000, olcott said:
>

On 6/13/2025 5:20 AM, Mikko wrote:

On 2025-06-12 15:34:01 +0000, olcott said:
>

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.
>
// rec routine P
//   §L :if T[P] go to L
//     Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{
   L: if (HHH(Strachey_P)) goto L;
   return;
}
>
https://academic.oup.com/comjnl/article-abstract/7/4/313/354243? redirectedFrom=fulltext
>
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.

>
False. It is not the reursive simulation that prevents the reaching
the simulation of the "return" statement. Instead, previention is
a consequence of the discontinuation of the simulation that the
input specifies.

>
When you try to prove this by providing ALL of the
details you will find that you are incorrect.

>
I don't need to prove anything. It is sufficient to point out that
you have not proven anything. For this discussion a sufficient
proof that HHH aborts is simulation is that you have said it does.

>
This code proves everything that I claimed beyond all possible doubt
https://github.com/plolcott/x86utm/blob/master/Halt7.c

>
More importantly, it proves what I climed: HHH does abort its simulation.
>

 *Just like it is required to do*
 <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
      H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
 

Except it can't have proven that D is a non-halting, since D will halt.
Of course, you need to decider which lies you are basing your logic on.
First is H (or your HHH) actually a program, and thus has a fixed behavior, so that when you decide that H does abort, that means that H has aways aborted at that point. If not, you failed at step one.
Then you have to decide if D (or your DD or DDD) is actually the program developed in the proof, and thus contains the code of that exact H defined above.
If not, then you have just admitted to lying about that fact for all these years.
And if so, then it is a fact if your H aborts as declared, then D will halt as it calls the H(D) that aborts and returns 0, which makes D halt.
Then you have to decide if you will accept that H(D) specifies that H is suppose to be deciding on that D or has some other meaning, and that the input is correctly expressed to provide the needed input for that decision.
Again, if it means anything else, then you are admitting that you have been lying about your D being the equivalent of the proof program.
And, if you admit to all the required definitions, then you run into the problem that since D() halts, H(D) needs to return 1, but it returns 0, and thus you have been lying about it returning the correct answer for all these years.
Until you show which of these steps was incorrect, it will be assumed that you have just admitted that you have just been lying for all these years and just don't have an excuse except that you were just too stupid to know what you were talking about, and were believing your own lies.