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

Op 03.aug.2024 om 16:37 schreef olcott:

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>

You can repeat this irrelevant quote many more times, but it is irrelevant, because it speaks about a correct simulation and HHH's simulation of itself is incorrect.
The simulation of a halting program halts.
That is a tautology in your terms. Disagreeing with it is denying a truism.
HHH halts, because it is coded to abort and halt.

 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

Still no evidence for your claim.
You may wish very, very much that it is correct. You can repeat many, many times the word 'correctly'. But it does not make it correct.

reach its own second instruction, thus cannot possibly reach
its own halt state of "return".

Proving that the simulation is incorrect.
H is programmed to abort and halt. When H would correctly simulate itself, the simulated H would return and D would reach the line following the call to H.
That it does not do that, proves that the simulation is incorrect.
H cannot possibly simulate itself correctly, because it aborts the simulation too soon. It does not even reach the part of D that contradict H's prediction.
Because H does a premature abort, you keep dreaming of a H that does not abort and does not terminate.
Dreams are no substitute for facts.