Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory
Subject: Re: D correctly simulated by H proved for THREE YEARS --- rewritten
Date: Tue, 18 Jun 2024 11:41:17 -0500
Organization: A noiseless patient Spider
Lines: 165
Message-ID: <v4sdbe$1eb2f$6@dont-email.me>
References: <v428vv$2no74$2@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>
 <v4i7ne$311i2$1@dont-email.me> <v4ia6l$31vjj$1@dont-email.me>
 <v4jlds$3cq2s$1@dont-email.me> <v4k0fc$3f0hc$1@dont-email.me>
 <v4k74f$3g29j$1@dont-email.me> <v4k7he$3gc4t$1@dont-email.me>
 <v4k8us$3g29j$3@dont-email.me> <v4k9kk$3gc4t$6@dont-email.me>
 <v4kb18$3gpbj$1@dont-email.me> <v4kbkv$3h3iu$2@dont-email.me>
 <v4m09f$3tvpi$1@dont-email.me> <v4mmai$1qt6$1@dont-email.me>
 <v4oo7t$hpjr$1@dont-email.me> <v4pcds$ln46$4@dont-email.me>
 <v4rj8m$180pg$2@dont-email.me> <v4rvcv$1boeu$1@dont-email.me>
 <v4s8st$1dcrb$2@dont-email.me> <v4s9mt$1dk9i$2@dont-email.me>
 <v4scrl$1edq0$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 18 Jun 2024 18:41:18 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="817dd47f58e869d78494e0bf13c00909";
	logging-data="1518671"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/eEo3DojWWdNA0jiVAeaPH"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:O4xecJ3/cOh3EZ6OZHmkPhwENKA=
Content-Language: en-US
In-Reply-To: <v4scrl$1edq0$1@dont-email.me>
Bytes: 8153

On 6/18/2024 11:32 AM, Mikko wrote:
> On 2024-06-18 15:39:09 +0000, olcott said:
> 
>> On 6/18/2024 10:25 AM, Fred. Zwarts wrote:
>>> Op 18.jun.2024 om 14:43 schreef olcott:
>>>> On 6/18/2024 4:16 AM, Fred. Zwarts wrote:
>>>>> Op 17.jun.2024 om 15:07 schreef olcott:
>>>>>> On 6/17/2024 2:22 AM, Mikko wrote:
>>>>>>> On 2024-06-16 12:37:38 +0000, olcott said:
>>>>>>>
>>>>>>>> On 6/16/2024 1:21 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 15.jun.2024 om 17:23 schreef olcott:
>>>>>>>>>> On 6/15/2024 10:12 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 15.jun.2024 om 16:48 schreef olcott:
>>>>>>>>>>>> On 6/15/2024 9:37 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Is this the new definition of "pathological"?
>>>>>>>>>>>>
>>>>>>>>>>>> *It is the same thing that I have been saying all along*
>>>>>>>>>>>>
>>>>>>>>>>>> 00   typedef void (*ptr)(); // pointer to void function
>>>>>>>>>>>> 01
>>>>>>>>>>>> 02   int HH(ptr P, ptr I);
>>>>>>>>>>>> 03
>>>>>>>>>>>> 04   void DDD(int (*x)())
>>>>>>>>>>>> 05   {
>>>>>>>>>>>> 06     HH(x, x);
>>>>>>>>>>>> 07     return;
>>>>>>>>>>>> 08   }
>>>>>>>>>>>> 09
>>>>>>>>>>>> 10   int main()
>>>>>>>>>>>> 11   {
>>>>>>>>>>>> 12     HH(DDD,DDD);
>>>>>>>>>>>> 13   }
>>>>>>>>>>>>
>>>>>>>>>>>> Line 12 main()
>>>>>>>>>>>>    invokes HH(DDD,DDD); that simulates DDD()
>>>>>>>>>>>>
>>>>>>>>>>>> *REPEAT UNTIL outer HH aborts*
>>>>>>>>>>>>    Line 06 simulated DDD()
>>>>>>>>>>>>    invokes simulated HH(DDD,DDD); that simulates DDD()
>>>>>>>>>>>>
>>>>>>>>>>>> DDD correctly simulated by HH never reaches its own "return"
>>>>>>>>>>>> instruction and halts.
>>>>>>>>>>>
>>>>>>>>>>> So, you agree that you are changing definitions.
>>>>>>>>>>
>>>>>>>>>> Not at all. The original definition still applies when it
>>>>>>>>>> is made more generic.
>>>>>>>>>>
>>>>>>>>>> 01       int D(ptr p)
>>>>>>>>>> 02       {
>>>>>>>>>> 03         int Halt_Status = H(p, p);
>>>>>>>>>> 04         if (Halt_Status)
>>>>>>>>>> 05           HERE: goto HERE;
>>>>>>>>>> 06         return Halt_Status;
>>>>>>>>>> 07       }
>>>>>>>>>>
>>>>>>>>>> D correctly simulated by H has isomorphic behavior to DDD
>>>>>>>>>> correctly simulated by HH, both get stuck in recursive
>>>>>>>>>> simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When asked what is a pathological program olcott replied:
>>>>>>>>> Op 14.jun.2024 om 21:18 schreef olcott:
>>>>>>>>>> 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 he defines a "pathological" program as a program that calls H.
>>>>>>>>> All words about doing the opposite of what H predicts, have 
>>>>>>>>> disappeared.
>>>>>>>>> Everyone sees the difference, but he is stuck is rebuttal mode 
>>>>>>>>> and denies the change of definition.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The code that "does the opposite" was never reachable by
>>>>>>>> a simulating halt decider thus does not change the problem
>>>>>>>> for a simulating halt decider when this code is removed.
>>>>>>>>
>>>>>>>> By simplifying the problem we gain cognitive leverage. With
>>>>>>>> less details to pay attention to the while simplified problem
>>>>>>>> can be more deeply understood.
>>>>>>>>
>>>>>>>>> His only excuse is that in both cases a recursive simulation is 
>>>>>>>>> seen, but that is not the point.
>>>>>>>>> He had already proved earlier that in
>>>>>>>>>
>>>>>>>>>        int main()
>>>>>>>>>        {
>>>>>>>>>          return H(main, 0);
>>>>>>>>>        }
>>>>>>>>>
>>>>>>>>> H produces a false negative, because main halts, whereas H reports
>>>>>>>>
>>>>>>>> The input does not halt and deciders are only accountable
>>>>>>>> for the behavior of their input.
>>>>>>>
>>>>>>> If the above main does not halt then H it calls is not a decider.
>>>>>>>
>>>>>>
>>>>>> That is merely a more difficult to understand
>>>>>> example of this simplest possible case.
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>>    H0(DDD);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    H0(DDD);
>>>>>> }
>>>>>>
>>>>>
>>>>> No, the other case is is simpler:
>>>>>
>>>>>         int main()
>>>>>         {
>>>>>           return H(main, 0);
>>>>>         }
>>>>>
>>>>> DDD is an unneeded complication. These four lines are sufficient to 
>>>>> see that there is no other reason for the false negative than H 
>>>>> itself.
>>>>>
>>>>> We understand that you do not like the simplest example, because it 
>>>>> shows that the reasoning that there is a difference between main 
>>>>> calling DDD(), or calling H0(DDD) is futile. In the simplest case 
>>>>> this futile trick is not possible.
>>>>> Therefore, we see that the whole problem is that H, or H0 is unable 
>>>>> to simulate itself sufficiently far enough to see the real 
>>>>> behaviour. It always aborts one cycle too early and, therefore, 
>>>>> produces false negatives.
>>>>
>>>> The is merely your lack or programming skill. The outer H0 always
>>>> has at least one more execution trace than any of the inner ones
>>>> thus if it does not abort none of them do.
>>>>
>>>
>>> Very good olcott! We agree on this point. At least you understand 
>>> something of programming.
>>
>> I worked for the Airforce at the Airforce base with a secret
>> clearance on the NPOESS Satellite ingest in C++.
>> https://en.wikipedia.org/wiki/NPOESS
> 
> That satellite mever flew.
> 

None-the-less it is a measure of my technical
competence. I worked for the Air Force weather
on another project for three years.

https://www.meteostar.com/solutionsmeteorology.html
This is when I got my secret clearance.

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
========== REMAINDER OF ARTICLE TRUNCATED ==========