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

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

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

On 2/24/2025 9:03 AM, dbush wrote:

On 2/24/2025 9:48 AM, olcott wrote:

On 2/24/2025 7:11 AM, dbush wrote:

On 2/24/2025 12:17 AM, olcott wrote:

On 2/23/2025 11:08 PM, dbush wrote:

On 2/24/2025 12:01 AM, olcott wrote:

>

Fine, we'll go by your more recent statement:
>
On 2/22/2025 1:02 PM, olcott wrote:
 > On 2/22/2025 11:10 AM, dbush wrote:
 >> On 2/22/2025 11:43 AM, olcott wrote:
 >>> The first point is DD correctly simulated by HHH cannot
 >>> possibly terminate normally by reaching its own "return"
 >>> instruction.
 >>
 >> In other words, if the code of HHH is replaced with an
unconditional simulator then it can be shown that DD is non-
halting and therefore HHH(DD)==0 is correct.
 >>
 >>
 > Wow finally someone that totally gets it.
>
>
Which stipulates that the behavior of no_numbers_greater_than_10
correctly simulated by F is decided by what this hypothetical
case will do:
>
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;
}
>
The above code proves that there's no way for
no_numbers_greater_than_10 correctly simulated by F to reach its
own "return" instruction.
>
Therefore F would be correct to report that
no_numbers_greater_than_10 is non-halting.
>
Agreed?
>
>
>

It looks like you have always been wrong about your code not
terminating. It looks like you never understood what you have been
talking  about.
>
>
>
>

I'll let you respond to yourself on this point:
>
On 11/10/2024 10:11 AM, olcott wrote:
 > If you had a basis in reasoning to show that I was wrong on
 > this specific point you could provide it. You have no basis in
 > reasoning on this specific point all you have is presumption.
>
>
>

You say that you code stops after ten recursions and also say that
it never stops.
>
>

int F(uintptr_t p)
{
    /* replace all code with an unconditional simulator */

>
No, not this at all. That would be nothing like HHH or HHH with its
abort code disabled.
>
>

 
It is exactly what you said X simulated by Y is defined to be:
 
On 2/22/2025 1:02 PM, olcott wrote:
 > On 2/22/2025 11:10 AM, dbush wrote:
 >> On 2/22/2025 11:43 AM, olcott wrote:
 >>> The first point is DD correctly simulated by HHH cannot possibly
 >>> terminate normally by reaching its own "return"
 >>> instruction.
 >>
 >> In other words, if the code of HHH is replaced with an
 >> unconditional
simulator then it can be shown that DD is non-halting and therefore
HHH(DD)==0 is correct.
 >>
 >>
 > Wow finally someone that totally gets it.
 
 
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 */

 
That is a stupid idea that has nothing to do with what I am taking
about.
HHH that aborts its simulation and a purely hypothetical (imaginary
never implemented) HHH that never aborts its simulation.