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

On 6/14/2025 9:53 AM, Mike Terry wrote:

On 14/06/2025 14:53, olcott wrote:

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
>
Mike verified everything that I claimed from this code except the
very last step of my proof. Mike demonstrated the non-halting behavior
pattern for infinite loops.

 I didn't demonstrate any such pattern.  I said such a pattern could clearly be formulated.
 Stop claiming that I support stuff I do not.  ("Everything that I claimed from this code" is at best too vague.  In fact just stop trying to use me as some kind of appeal to authority.  Make your own arguments.
 

You did demonstrate exactly how my code could correctly
recognize an infinite loop when you showed the repeating
pattern of this infinite loop.
On 5/14/2025 7:36 PM, Mike Terry wrote:
 > There is a natural (and correct) statement that Sipser
 > is far more likely (I'd say) to have agreed to.
 >
 > First you should understand the basic idea behind a
 > "Simulating Halt Decider" (*SHD*) that /partially/
 > simulates its input, while observing each simulation
 > step looking for certain halting/non-halting patterns
 > in the simulation. A simple (working) example here
 > is an input which goes into a tight loop.
(Mike says much more about this)
*Click here to get the whole article*
On 5/14/2025 7:36 PM, Mike Terry wrote:
we can easily interpret that as saying exactly what I said a SHD
does above. It tells PO that in the tight loop example, H correctly
simulates as far as [A], at which point it correctly determines that
"its simulated input would never stop running unless aborted",
so it can decide "non-halting".
On 5/14/2025 7:36 PM, Mike Terry wrote:
https://al.howardknight.net/?STYPE=msgid&MSGI=%3C1003cu5%242p3g1%241%40dont-email.me%3E

He might understand the non-halting
behavior patterns for infinite recursion.

 I do - it is unsound, as I told you 3 years ago, and several times

void Infinite_Recursion()
{
   Infinite_Recursion();
}
Any first year CS student would be able to determine
that the above function never halts.
_Infinite_Recursion()
[000020f2] 55             push ebp
[000020f3] 8bec           mov ebp,esp
[000020f5] e8f8ffffff     call 000020f2
[000020fa] 5d             pop ebp
[000020fb] c3             ret
Size in bytes:(0010) [000020fb]
Any computer science graduate would be able to determine
the criteria to correctly detect this infinite recursion.

since.  I suggested that if your conclusion depended on it being sound you need to provide a PROOF that it is sound.  Given that you can't do that, you might as well give up and do something else, because your result will never even be looked at seriously without such a proof.  [That's setting aside the problem that the test is unsound, deciding never-halts for certain halting computations.  So no proof of soundness is even possible.]
 

>
The only thing left is understanding the non-halting behavior
pattern of recursive simulation.

 Dude - that's one of your intuitions that's simply WRONG, as you were told 3+ years ago.
  Mike.
 

*I have much better words than I had three years ago*
void DDD()
{
   HHH(DDD);
   return;
}
int main()
{
   DDD() // calls HHH(DDD)
}
It turns out that all of the rebuttals are based on
the incorrect requirement that HHH(DDD) must report
on the behavior of its caller rather than the sequence
of state transitions that its input actually specifies.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer