olcott <NoOne@NoWhere.com> writes:
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
No. H(P,P) == 0 is correct if, and only if, P(P) does not halt. But (according to you -- we are not allowed to see the full code) P(P)
halts:
|| Here's the key question: do you still assert that H(P,P) == false is
|| the "correct" answer even though P(P) halts?
| Yes that is the correct answer even though P(P) halts.
No waffle can alter the fact that false (or 0 etc.) is the wrong return.
On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
// Simplified Linz Ĥ (Linz:1990:319)I can see where the confusion lies. If H never aborts, it simulates P forever.
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}
We can analyze H(P,P) at the very high level of abstraction of its two
possible behaviors relative to its input allows us to concisely prove
that not halting <is> the correct decision for this input. No matter how
H works internally the only thing that counts is the behavior of its
input for the two possible behaviors that H can have.
Since the input to H(P,P) never reaches its final state for the two
possible behaviors that every H can possibly have (abort the input or do
not abort the input) then we can conclude that not halting is the
correct decision for every possible simulating halt decider H.
If it aborts, then it aborts because it has detected that otherwise P would simulate forever.
What you are forgetting is that P depends on H. If H aborts, the P would also abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
that if it didn't abort, P would run forever.
That seems like a contradiction, but it isn't really, because we are talking about two Ps, one with an H which never aborts, one with an H that aborts.
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
// Simplified Linz Ĥ (Linz:1990:319)I can see where the confusion lies. If H never aborts, it simulates P forever.
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}
We can analyze H(P,P) at the very high level of abstraction of its two
possible behaviors relative to its input allows us to concisely prove
that not halting <is> the correct decision for this input. No matter how >>> H works internally the only thing that counts is the behavior of its
input for the two possible behaviors that H can have.
Since the input to H(P,P) never reaches its final state for the two
possible behaviors that every H can possibly have (abort the input or do >>> not abort the input) then we can conclude that not halting is the
correct decision for every possible simulating halt decider H.
If it aborts, then it aborts because it has detected that otherwise P would >> simulate forever.
What you are forgetting is that P depends on H.
What makes you think he's forgetting that? Having (at least) two
different Hs without changing H^ (now called P) has been the ruse for
months and months.
His Halts function was declared correct because of what would happen if
line 15 were commented out. It has always been some variation of the
theme of "the wrong answer is right because of what would happen if H
(but not H^) were not the function it really is".
If H aborts, the P would also
abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
that if it didn't abort, P would run forever.
That seems like a contradiction, but it isn't really, because we are talking >> about two Ps, one with an H which never aborts, one with an H that
aborts.
Do you think the change of name from a dependent one (H^) to one that
hides the dependence (P) is an accident? Might is not be part of the
scheme to find words that make the wrong answer, H(P,P) == false, seem
less wrong despite the fact that P(P) halts?
olcott <NoOne@NoWhere.com> writes:
|| Here's the key question: do you still assert that H(P,P) == false is
|| the "correct" answer even though P(P) halts?
To which you replied (but have for some reason cut from this post)
| Yes that is the correct answer even though P(P) halts.
H(P,P) reports that its input never halts.
H(P,P) should report on whether P(P) halts. Stating that the wrong
answer is the right one is not how mathematics is done.
olcott <NoOne@NoWhere.com> writes:
On 11/1/2021 5:38 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
To which you replied (but have for some reason cut from this post)|| Here's the key question: do you still assert that H(P,P) == false is >>>>> || the "correct" answer even though P(P) halts?
H(P,P) should report on whether P(P) halts. Stating that the wrong| Yes that is the correct answer even though P(P) halts.
H(P,P) reports that its input never halts.
answer is the right one is not how mathematics is done.
H1(P,P) is computationally equivalent to P(P).
H(P,P) is not computationally equivalent to P(P).
H(P,P) == false is wrong if P(P) halts.
This comes from the definition
of the problem you have been studying for more than 14 years. I think
it's time you did something else. It seems such a waste...
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (3 / 13) |
Uptime: | 00:08:49 |
Calls: | 7,836 |
Calls today: | 5 |
Files: | 12,933 |
Messages: | 5,771,757 |