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

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

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.

So, you agree that you are changing definitions. The part in your definition above "and then specifically do the opposite of what H predicts D will do" has completely disappeared.
Don't you see that it is almost impossible to talk with someone who is continuously changing definitions?
But when using this new definition, we agree that the fact that D does the opposite of what H returns is irrelevant.
This means that you only prove that there are programs (like your DDD, and my main) that halt, for which the simulation by H does not reach its final state, because H is unable to reach its own simulated final state. H then aborts and reports non-halting. A false negative.