Re: key error in all the proofs --- Mike's correction of Joes

On 2024-08-16 11:39:15 +0000, olcott said:

On 8/16/2024 3:13 AM, Mikko wrote:

On 2024-08-15 13:18:06 +0000, olcott said:
 

On 8/15/2024 2:01 AM, joes wrote:

Am Wed, 14 Aug 2024 16:08:34 -0500 schrieb olcott:

On 8/14/2024 3:56 PM, Mike Terry wrote:

On 14/08/2024 18:45, olcott wrote:

On 8/14/2024 11:31 AM, joes wrote:

Am Wed, 14 Aug 2024 08:42:33 -0500 schrieb olcott:

On 8/14/2024 2:30 AM, Mikko wrote:

On 2024-08-13 13:30:08 +0000, olcott said:

On 8/13/2024 6:23 AM, Richard Damon wrote:

On 8/12/24 11:45 PM, olcott wrote:

 *DDD correctly emulated by HHH cannot possibly reach its* *own
"return" instruction final halt state, thus never halts*
 

Which is only correct if HHH actuallly does a complete and
correct emulation, or the behavior DDD (but not the emulation of
DDD by HHH)
will reach that return.
 

A complete emulation of a non-terminating input has always been a
contradiction in terms.
HHH correctly predicts that a correct and unlimited emulation of
DDD by HHH cannot possibly reach its own "return" instruction
final halt state.

 That is not a meaningful prediction because a complete and
unlimited emulation of DDD by HHH never happens.
 

A complete emulation is not required to correctly predict that a
complete emulation would never halt.

What do we care about a complete simulation? HHH isn't doing one.
 

Please go read how Mike corrected you.
 

Lol, dude...  I mentioned nothing about complete/incomplete
simulations.

*You corrected Joes most persistent error*
She made sure to ignore this correction.

Would you please point it out again?
 

 I did in the other post.
 

But while we're here - a complete simulation of input D() would clearly
halt.

A complete simulation *by HHH* remains stuck in infinite recursion until
aborted.

Yes, HHH can't simulate itself completely. I guess no simulator can.
 

 A simulating termination analyzer can correctly simulate
itself simulating an input that halts.
 void DDD()
{
   HHH(DDD);
   return;
}

 That DDD halts if HHH halts but at least your HHH fails to simulate
itself with DDD as parameter to its return. Perhaps it can simulate
 void XXX() {
 HHH(YYY);
}
 void YYY() {
 Output("Hello!");
}
 

 void YYY()
{
  OutputString("Hello!\n");
}
 void XXX()
{
  HHH(YYY);
}
 int main()
{
  XXX();
}
 When corrected your code ran fine.
You never have HHH simulating itself.

Thanks!
You seem to have two output functions: Output and OutputString.
What is the differece?
I would expect that HHH says that YYY halts. Have you tried?
What does HHH say about XXX?
--
Mikko