Re: D correctly simulated by H proved for THREE YEARS --- rewritten

On 6/18/2024 2:54 AM, Mikko wrote:

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

On 6/17/2024 2:22 AM, Mikko wrote:

On 2024-06-16 12:37:38 +0000, olcott said:
>

On 6/16/2024 1:21 AM, Fred. Zwarts wrote:

Op 15.jun.2024 om 17:23 schreef olcott:

On 6/15/2024 10:12 AM, Fred. Zwarts wrote:

Op 15.jun.2024 om 16:48 schreef olcott:

On 6/15/2024 9:37 AM, Fred. Zwarts wrote:

>
Is this the new definition of "pathological"?

>
*It is the same thing that I have been saying all along*
>
00   typedef void (*ptr)(); // pointer to void function
01
02   int HH(ptr P, ptr I);
03
04   void DDD(int (*x)())
05   {
06     HH(x, x);
07     return;
08   }
09
10   int main()
11   {
12     HH(DDD,DDD);
13   }
>
Line 12 main()
   invokes HH(DDD,DDD); that simulates DDD()
>
*REPEAT UNTIL outer HH aborts*
   Line 06 simulated DDD()
   invokes simulated HH(DDD,DDD); that simulates DDD()
>
DDD correctly simulated by HH never reaches its own "return"
instruction and halts.

>
So, you agree that you are changing definitions.

>
Not at all. The original definition still applies when it
is made more generic.
>
01       int D(ptr p)
02       {
03         int Halt_Status = H(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
>
D correctly simulated by H has isomorphic behavior to DDD
correctly simulated by HH, both get stuck in recursive
simulation.
>

>
When asked what is a pathological program olcott replied:
Op 14.jun.2024 om 21:18 schreef olcott:

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. No H can exist that handles this case.

>
>
No he defines a "pathological" program as a program that calls H.
All words about doing the opposite of what H predicts, have disappeared.
Everyone sees the difference, but he is stuck is rebuttal mode and denies the change of definition.
>

>
The code that "does the opposite" was never reachable by
a simulating halt decider thus does not change the problem
for a simulating halt decider when this code is removed.
>
By simplifying the problem we gain cognitive leverage. With
less details to pay attention to the while simplified problem
can be more deeply understood.
>

His only excuse is that in both cases a recursive simulation is seen, but that is not the point.
He had already proved earlier that in
>
       int main()
       {
         return H(main, 0);
       }
>
H produces a false negative, because main halts, whereas H reports

>
The input does not halt and deciders are only accountable
for the behavior of their input.

>
If the above main does not halt then H it calls is not a decider.
>

>
That is merely a more difficult to understand
example of this simplest possible case.
>
void DDD()
{
   H0(DDD);
}
>
int main()
{
   H0(DDD);
}

 The only parts that are not easy to understand are H and H0 because
they are not shown. The rest of both examples are simple enough.
 

typedef void (*ptr)();
int H0(ptr P);
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   H0(DDD);
}
int main()
{
   H0(Infinite_Loop);
   H0(Infinite_Recursion);
   H0(DDD);
}
Every C programmer that knows what an x86 emulator is knows that
when H0 emulates the machine language of Infinite_Loop, Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
If you don't understand that the above is correct then you
either don't know what an x86 emulator is or don't know C
well enough.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer