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

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. Further that every program that uses H has the same problem. E.G.,
        int main()
        {
          return H(main, 0);
        }
It has no "pathological" part that does the opposite of what H returns. But it has the same problem that H reports that it is not halting, because H is trying to simulate itself.
Since the pathological part of D does not play a role in your claim, it is less confusing to name the problem "H simulating itself".

 

>
HH(DD,DD) does have a pathological relationship to its input
thus this input CANNOT POSSIBLY terminate normally.

>
Yes, indeed! Well done! The input of HH(DD,DD) is aborted too early,

 If the input is never aborted THEN IT NEVER TERMINATES.

  (personal attach ignored)
Yes indeed! Very clever of you!
But it is aborted! Unfortunately, one cycle too early, one cycle before it would see the abort of the simulated H. So, dreaming of an H that never aborts does not tell us anything about the H that aborts.

 

because HH cannot possibly simulate itself up to its final state. That means that its simulation cannot terminate normally.
>

 *It is D that calls H in recursive simulation*

*And* it is H that starts new simulations of D in recursion. If the simulated H would halt (as required), D would return.
It is a pity for H, but it is programmed to do that (and for a simulator, there is probably no better way), so it will never see the end of its own simulation and the return to D, let alone that it would see the "pathological" part of D.

 

>

It is only that H simulated by itself is aborted too early. Is that so difficult to understand for you?
>

Aborted too early is false.
Unless HH(DD,DD) aborts pretty soon HH and DD crash due to
out-of-memory error.
>

If H waits for some other H to abort their
simulation then H waits forever.

>
There is no other H.

>
Clearly you hardly understand anything that I have been saying.
(a) HH(DD,DD) directly executed in main simulates its input.
(b) The simulated DD calls a simulated HH(DD,DD) that
(c) simulates another instance of DD... goto (b)

I understand that very well, a, b, c explain why HH is not able to simulate itself up to the end. You are proving my claims.
>
Another way of saying the same thing is:
1) HH starts simulating DD

 Until H sees that D correctly simulated by H cannot
possibly terminate normally.

Because H is unable to simulate itself correctly up to its final state.
So, since we seem to agree that a correct simulation of H by H would not terminate, the only escape is an incorrect simulation which aborts the simulation.
Unfortunately, this incorrect simulation aborts one cycle too early and therefore misses the part where the simulated H would abort, return to the "pathological" part of D and D would halt.