Re: DD specifies non-terminating behavior to HHH --- RECURSIVE CHAIN --- Saving Democracy

On 2/24/2025 8:59 PM, olcott wrote:

On 2/24/2025 7:51 PM, dbush wrote:

On 2/24/2025 8:47 PM, olcott wrote:

On 2/24/2025 7:26 PM, dbush wrote:

On 2/24/2025 8:12 PM, olcott wrote:

On 2/24/2025 6:06 PM, dbush wrote:

On 2/24/2025 6:16 PM, olcott wrote:

On 2/24/2025 3:47 PM, dbush wrote:

On 2/24/2025 4:26 PM, olcott wrote:

>
>

>
HHH that aborts its simulation and a purely
hypothetical (imaginary never implemented)
HHH that never aborts its simulation.
>

>
>
Same thing.  F aborts its (admittedly poor) simulation by breaking out of a recursive chain, and a hypothetical F that performs a correct unaborted simulation.

>
The simple fact that the hypothetical HHH would never
terminate conclusively proves that DD specifies behavior
that cannot possibly terminate normally.

>
And the simple fact that the hypothetical F would never terminate conclusively proves that no_numbers_greater_than_10 specifies behavior that cannot possibly terminate normally.
>
Agreed?

>
I will not discuss your code.
>

>
I'll let you respond to yourself here:
>
On 11/10/2024 11:41 PM, olcott wrote:
 > That is a dishonest dodge. An honest rebuttal would explain
 > all of the details of how I am incorrect. You can't do that
 > because I am correct.
>
>

 Your code is not isomorphic to my code thus an
irrelevant change of subject away from the point.
 

That is counter-factual.
According to you, the behavior of DD correctly simulated by HHH is defined by this code:
int HHH(ptr P)
{
     /* replace all code with an unconditional simulator */
}
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   HHH(DD);
}
Likewise, the behavior of no_numbers_greater_than_10 correctly simulated by F is defined by this code:
int F(uintptr_t p)
{
    /* replace all code with an unconditional simulator */
}
int no_numbers_greater_than_10()
{
    return F((uintptr_t)no_numbers_greater_than_10);
}
int main()
{
    F((uintptr_t)no_numbers_greater_than_10);
    return 0;
}
There is no functional difference between these two pieces of code.
So if DD correctly simulated by HHH cannot halt and shows that DD is non-halting, then no_numbers_greater_than_10 correctly simulated by F cannot halt and shows that no_numbers_greater_than_10  is non halting.
Similarly, if we determine that no_numbers_greater_than_10 halts, then DD halts.
So pick one:
* no_numbers_greater_than_10 halts and DD halts
* no_numbers_greater_than_10 does not halt and DD does not halt