Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis

On 6/9/24 9:45 AM, olcott wrote:

On 6/9/2024 3:15 AM, Mikko wrote:

On 2024-06-08 13:43:17 +0000, olcott said:
>

On 6/8/2024 8:03 AM, Richard Damon wrote:

On 6/7/24 11:36 PM, olcott wrote:

>
DD(DD) is just like infinite recursion that gets terminated at
its second recursive call. DD(DD) halts only because HH(DD,DD)
correctly determines that its input DOES NOT HALT.

>
Except a potentially infinite loop that has code that breaks out of that loop will halt.
>

>
<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>
>
No you are wrong.

>
It does not make much sense to say "you are wrong" without saying
about what and what is right instead.
>
Besides, there should be either a comma after "No" or the word "not"
after "are". We may guess from context which one you meant but a
guess is only a guess.
>

 *It is no mere loop it is isomorphic to 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
     simulating halt decider HHH correctly simulates its input DDD
    until HHH correctly determines that its simulated DDD would never
    stop running unless aborted
 

Except if you change the input to call a different "decider" you have a different input, so it can behave differently.
You can only decide on actual program intances, not just the "template", as the template doesn't have a behavior by itself.
I will note that your arguments STILL think that a call to a specific address doesn't need to have the simulation continue at that address, and it can reach an address again that is never actually reached.
Both of these are considered "Correct" to you even in violation of your own definitions.