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

On 6/15/24 10:48 AM, olcott wrote:

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()

But that also means that when the input program is run, the HH called by DDD will ALSO abort and return 0, so the input is properly halting.

 DDD correctly simulated by HH never reaches its own "return"
instruction and halts.
 

So it Halts but doesn't POOP.
Maybe your HH is a proper POOP decider, but who cares.