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

On 2/22/2025 1:54 PM, olcott wrote:

On 2/22/2025 12:21 PM, dbush wrote:

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:

On 2/22/2025 5:01 AM, joes wrote:

Am Fri, 21 Feb 2025 21:55:32 -0600 schrieb olcott:

On 2/20/2025 4:00 AM, joes wrote:

>
>

Not even the variable Root in line 502 of Halt7.c?

https://github.com/plolcott/x86utm/blob/master/Halt7.c You are not even
in the correct function.

1059
>

>
Unless we go through a 100% precise sequence of steps
my reviewers will always consistently dodge the point
as they have done for several years.
>
typedef void (*ptr)();
int HHH(ptr P);
>
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
int main()
{
   HHH(DD);
}
>
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.
>

Let's test that on another case.
>

01 int F(int i)
02 {
03      if (i<10) {
04          return 0;
05      } else {
06          return F(i+1);
07      }
08 }
09
10 int no_numbers_greater_than_10()
11 {
12      return F(0);
13 }
14
15 int main()
16 {
17   no_numbers_greater_than_10();
18   return 0;
19 }

>
Actually, let's update main:
>
int main()
{
    F((int)no_numbers_greater_than_10);
    return 0;
}
>

>
The function no_numbers_greater_than_10() checks if any natural number exists that is greater than 10.  It does this by checking all natural numbers one at a time.  If one such number exists it halts and return 0.   If no such number exists, it will run forever as no such number will satisfy the condition.
>

>
Your code is incomplete. I added main() with line numbers.
>

We can see that no_numbers_greater_than_10 correctly simulated by F cannot possibly terminate normal by reaching its own "return" instruction.  This means that F correctly reports that no_numbers_greater_than_10 is non-halting.  It further means, since no_numbers_greater_than_10  doesn't halt that there is no natural number greater than 10.
>
Agreed?

>
Here the execution trace that I see:
15, 16, 17, 10, 11, 12, 01, 02, 03, 04, 12, 18, 19
>

>
Just as you say we're not talking about the direct execution of DD, we're also not talking about the direct execution of no_numbers_greater_than_10.  We're talking about no_numbers_greater_than_10 correctly simulated by F.
>
It's a verified fact that no_numbers_greater_than_10 correctly simulated by F cannot possibly return so F(no_numbers_greater_than_10) is correct to report non-halting, which means that there is no natural number greater than 10.
>
Agreed?
>

 Leaving out main() made this difficult.
We can assume that the address of no_numbers_greater_than_10 > 10.
This will emulate no_numbers_greater_than_10 at incorrect byte offsets
causing it to crash. This may or may not make F crash depending
on how robust its emulator is.
 

Let's make a small change so that wraparound is well defined:
int F(uintptr_t i)
{
      if (i<10) {
          return 0;
      } else {
          return F(i+1);
      }
}
This ensures that F((uintptr_t)no_numbers_greater_than_10) returns 0.
This doesn't change the fact that no_numbers_greater_than_10 correctly
simulated by F cannot possibly return so F(no_numbers_greater_than_10)
is correct to report non-halting, which means that there is no natural
number greater than 10.
Agreed?