Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: "Fred. Zwarts" <F.Zwarts@HetNet.nl>
Newsgroups: comp.theory,sci.logic
Subject: Re: D correctly simulated by H proved for THREE YEARS --- rewritten
Date: Fri, 14 Jun 2024 22:03:57 +0200
Organization: A noiseless patient Spider
Lines: 97
Message-ID: <v4i7ne$311i2$1@dont-email.me>
References: <v428vv$2no74$2@dont-email.me> <v43ib7$38hnd$1@dont-email.me>
 <v4628o$6ero$1@dont-email.me> <v468qt$7uvj$1@dont-email.me>
 <v47joj$je45$1@dont-email.me> <v47kt3$jhs8$1@dont-email.me>
 <v47l92$je45$2@dont-email.me> <v48tt4$tqad$1@dont-email.me>
 <v4a07r$157ic$1@dont-email.me> <v4beis$1h0p6$1@dont-email.me>
 <v4cceu$1mi5i$2@dont-email.me> <v4corm$1p0h0$1@dont-email.me>
 <v4cp5s$1pe0q$1@dont-email.me> <v4cs0b$1p0h1$1@dont-email.me>
 <v4csdq$1q0a8$1@dont-email.me> <v4ctuq$1p0h1$2@dont-email.me>
 <v4cuc6$1qedu$1@dont-email.me> <v4e9qm$25ks0$1@dont-email.me>
 <v4epji$28g4v$2@dont-email.me> <v4fhj3$2dce5$1@dont-email.me>
 <v4fi0m$2dvk4$1@dont-email.me> <v4h4ag$2q9hc$1@dont-email.me>
 <v4he7s$2sdqr$4@dont-email.me> <v4i41a$30e5b$1@dont-email.me>
 <v4i52u$30usa$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Fri, 14 Jun 2024 22:03:58 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="c33fd6fcd22a4d618b237757ed897b89";
	logging-data="3180098"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/McyE9/IsHVPOrfWBqxCcD"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:yPPHBmsDX9+DNBrOcd1hLJdFQaA=
Content-Language: en-GB
In-Reply-To: <v4i52u$30usa$1@dont-email.me>
Bytes: 5601

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.