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 17:20 schreef olcott:

On 8/3/2024 10:03 AM, Fred. Zwarts wrote:

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.

 When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH cannot possibly simulate itself correctly.
Anyone trying to simulate HHH by itself fails, because it must deviate from the semantics of the x86 language.
Dreaming that a program that deviates from the semantics is still correct are no substitute for facts.