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

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

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.

But not necessarily INFINITE recursive simulation.
For example:
int test(ptr x) {
     return 0;
}
int infinite_loop(ptr x) {
    while(1) continue;
    return 0;
}
int D0(ptr x) {
    H(test, test);
    return 1;
}
int main() {
     H(D0,D0);
     return 0;
}
are you claiming that just because D calls H(test,test) that this makes D non-halting due to recursive simulation?
OR if D instead calls H on infinite_loop that H has been programmed to detect makes D non-halting due to recursive simulation.
Basic principle, if D calls H on an input that H will eather be able to simulate to the end, or that H decides to abort its simulation of, such a call should not be indication of "non-halting" behavior.
the call to H(test, test) or H(infinite_loop, infinite_loop) are not fundamentally different than the call the H(D0,D0) on this basis.
And thus for the above non-pathological D0, it should be expected that H, if it is a proper decider, should be able to get the answer, since it is possible.
The fact that you H never get to the point of seeing the difference between non-pathological D0 and the pathological D means that H isn't doing the best job it can. and maybe your approach is just flawed.
Thus, we show that the mear fact that D calls H(D,D) is NOT by itself proper ground for calling the input non-halting, but is based on INCORRECT LOGIC.

 

Maybe if you were a PhD computer science professor you would
understand this.

>
Many people without a PhD understand your are continuously changing definitions. No PhD needed. I am sorry for you if you don't grasp it.
(Btw, I never refer to my PhD, because I think arguments should convince, not authority.)