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

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"?
Again a change of definition. No words any more about doing the opposite of what H predicts. Words you used in the definition only a few lines above have disappeared.
So, with 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 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.
Further, it is not the function that specifies recursive simulation. The function does not even know about recursion. It is H that starts the recursive simulation, with the effect that its must simulate itself.
More important, it does not specify infinite recursion. Only if H does not halt, as required, an infinite recursion happens.