Re: Proof that DD correctly simulated by HH has different behavior than DD(DD) STEP(1)

On 6/9/24 10:13 AM, olcott wrote:

On 6/9/2024 1:33 AM, Fred. Zwarts wrote:

Op 08.jun.2024 om 20:47 schreef olcott:

Before we can get to the behavior of the directly executed
DD(DD) we must first see that the Sipser approved criteria
have been met:
>
<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 words10/13/2022>
>
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.
>
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.

>
Stopping at your first error. So, we can focus on it. Your are asking a question that contradicts itself.
A correct simulation of HH that aborts itself, should simulate up to the point where the simulated HH aborts. That is logically impossible. So, either it is a correct simulation and then we see that the simulated HH aborts and returns, or the simulation is incorrect, because it assumes incorrectly that things that happen (abort) do not happen.
A premature conclusion.
>
>

 I have a clearer explanation now that I have gone through
all of Mikko's posts: (you must know C to understand this)
 typedef void (*ptr)(); // pointer to void function
 void HHH(ptr P, ptr I)
{
   P(I);
   return;
}
 void DDD(int (*x)())
{
   HHH(x, x);
   return;
}
 int main()
{
   HHH(DDD,DDD);
}
 In the above Neither DDD nor HHH ever reach their own return
statement thus never halt.
 When HHH is a simulating halt decider then HHH sees that
DDD correctly simulated by HHH cannot possibly reach its
own return statement, AKA

But by the above, it isn't. That is just par for your course, you like to assume things are what they are not and don't bother to check.
That is why you are wrong so often, and your arguments just invalid

     simulating halt decider HHH correctly simulates its input DDD
    until HHH correctly determines that its simulated DDD would never
    stop running unless aborted