Re: Who here is too stupid to know that DDD correctly simulated by HHH cannot possibly reach its own return instruction?

On 8/3/2024 9:08 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:58 schreef olcott:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:
>

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?
>
void DDD()
{
   HHH(DDD);
   return;
}

>
Everyone here understands that that depends on whther HHH returns.
>

>
Fred's understanding is worse than that.
Some have deeper understanding than that.
>
*Ben has the best understanding of all*
>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game.  PO really /has/ an H
 > (it's trivial to do for this one case) that correctly determines
 > that P(P) *would* never stop running *unless* aborted.
...
 > But H determines (correctly) that D would not halt if it
 > were not halted.  That much is a truism.
>

 we are talking about H that aborts and halts.
Dreaming of a HHH that does not halt if it were no halted may be relaxing, but it is completely irrelevant.
Olcott still does not understand that such dreams have no effect on the coded HHH that is programmed to abort and halt.
When it halts it halts, but that is already too difficult for olcott.
He keeps dreaming of HHH that does not halt.

*Ben's understanding is correct yours is incorrect*
Ben's understanding refers to applying this criteria
to the following code where H(D,D) halts.
<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>
int D(int (*x)())
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   H(D,D);
}
In the above code D correctly simulated by H cannot possibly
reach its own second instruction, thus cannot possibly reach
its own halt state of "return".
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer