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

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

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

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

Op 15.jun.2024 om 14:12 schreef olcott:

On 6/15/2024 4:03 AM, Fred. Zwarts wrote:

Op 14.jun.2024 om 22:46 schreef olcott:

On 6/14/2024 3:03 PM, Fred. Zwarts wrote:

Op 14.jun.2024 om 21:18 schreef olcott:

On 6/14/2024 2:00 PM, Fred. Zwarts wrote:

Op 14.jun.2024 om 14:49 schreef olcott:

I ran the actual code to verify the facts.
HH1(DD,DD) does not have a pathological relationship to its input
thus this input terminates normally.

>
Your terminology is confusing. What you call a "pathological relationship" is that H must simulate itself.
>

>
*CONVENTIONAL TERMINOLOGY*
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.
https://en.wikipedia.org/wiki/Halting_problem

>
The problem is that your simulator does not even reach the "pathological" part of D.

>
That is not the problem that is the criterion measure of a solution.

>
You are using the wrong criterion, because this wrong criterion also also applies to other programs, without a "pathological" part.
>
        int main()
        {
          return H(main, 0);
        }
>
where you proved that H reports a false negative.
>
So, your criterion has no relation with "pathological" programs.
>

>
This criteria works correctly for ALL input, including pathological
main().

>
You are twisting your own words,because main is not "pathological".
You do not even understand you own definition of "pathological":
>
Op 14.jun.2024 om 21:18 schreef olcott:

>
*CONVENTIONAL TERMINOLOGY*
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 high level programming skills are needed to see that there is no part where main 'then specifically do the opposite of what H predicts it will do'.
>
It seems that you are changing the definition of "pathological" to 'any program for which H returns a false negative', which then becomes a tautology.
>

>
Any function that calls H specifies recursive simulation.

 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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer