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: 195 page execution trace of DDD correctly simulated by HH0
Date: Tue, 25 Jun 2024 21:17:34 +0200
Organization: A noiseless patient Spider
Lines: 206
Message-ID: <v5f54f$1lp16$3@dont-email.me>
References: <v4vrfg$2793f$1@dont-email.me> <v58m12$8mmo$1@dont-email.me>
 <v59797$brmn$1@dont-email.me> <v5b7nv$qvrb$1@dont-email.me>
 <v5btf3$v0vb$4@dont-email.me> <v5chru$10816$1@i2pn2.org>
 <v5cn01$149dc$1@dont-email.me> <v5ebvr$1hs89$1@dont-email.me>
 <v5efod$1ikpr$1@dont-email.me> <v5ejau$1iq57$1@dont-email.me>
 <v5eup8$1lar1$2@dont-email.me> <v5f1nm$1lp16$1@dont-email.me>
 <v5f246$1m2fl$1@dont-email.me> <v5f3fg$1lp16$2@dont-email.me>
 <v5f3j8$1m2fl$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 25 Jun 2024 21:17:35 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="c4ff8408f3b943eae31dc22ab1458b62";
	logging-data="1762342"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19zH3RxYd/yJ/MMLKBpNFU6"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:kRPRysEGjYylpWugS8KYUqrQNn0=
In-Reply-To: <v5f3j8$1m2fl$2@dont-email.me>
Content-Language: en-GB
Bytes: 9900

Op 25.jun.2024 om 20:51 schreef olcott:
> On 6/25/2024 1:49 PM, Fred. Zwarts wrote:
>> Op 25.jun.2024 om 20:26 schreef olcott:
>>> On 6/25/2024 1:19 PM, Fred. Zwarts wrote:
>>>> Op 25.jun.2024 om 19:29 schreef olcott:
>>>>> On 6/25/2024 9:13 AM, Fred. Zwarts wrote:
>>>>>> Op 25.jun.2024 om 15:12 schreef olcott:
>>>>>>> On 6/25/2024 7:08 AM, Fred. Zwarts wrote:
>>>>>>>> Op 24.jun.2024 om 23:04 schreef olcott:
>>>>>>>>> On 6/24/2024 2:36 PM, joes wrote:
>>>>>>>>>> Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:
>>>>>>>>>>> On 6/24/2024 2:37 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-06-23 13:17:27 +0000, olcott said:
>>>>>>>>>>>>> On 6/23/2024 3:22 AM, Mikko wrote:
>>>>>>>>>>>>>> That code is not from the mentined trace file. In that 
>>>>>>>>>>>>>> file _DDD()
>>>>>>>>>>>>>> is at the addresses 2093..20a4. According to the trace no 
>>>>>>>>>>>>>> instruction
>>>>>>>>>>>>>> at the address is executed (because that address points to 
>>>>>>>>>>>>>> the last
>>>>>>>>>>>>>> byte of a three byte instruction.
>>>>>>>>>>>>>
>>>>>>>>>>>>> In order to make my examples I must edit the code and this 
>>>>>>>>>>>>> changes the
>>>>>>>>>>>>> addresses of some functions.
>>>>>>>>>>>>
>>>>>>>>>>>> Why do you need to make an example when you already have one 
>>>>>>>>>>>> in the
>>>>>>>>>>>> file mentioned in the subject line?
>>>>>>>>>>>>
>>>>>>>>>>> I had to make a few more examples such as HH1(DD,DD)
>>>>>>>>>> AFACT HH1 is the same as HH0, right? What happens when HH1 
>>>>>>>>>> tries to
>>>>>>>>>> simulate a function DD1 that only calls HH1?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> typedef uint32_t u32;
>>>>>>>>> u32 H(u32 P, u32 I);
>>>>>>>>>
>>>>>>>>> int P(u32 x)
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    H(P,P);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> I am going to have to go through my code and standardize my names.
>>>>>>>>> H(P,P) was the original name. Then I had to make a one parameter
>>>>>>>>> version, a version that is identical to H, except P does not call
>>>>>>>>> it and then versions using different algorithms. People have never
>>>>>>>>> been able to understand the different algorithm.
>>>>>>>>>
>>>>>>>>> typedef void (*ptr)();
>>>>>>>>> typedef int (*ptr2)();
>>>>>>>>> int  HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>>>> int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
>>>>>>>>> int  HHH(ptr P);         // used with void DDD() that calls HHH
>>>>>>>>> int HHH1(ptr P);         // used with void DDD() that calls HHH
>>>>>>>>>
>>>>>>>>> *The different algorithm version has been deprecated*
>>>>>>>>> int  H(ptr2 , ptr2 I);  // used with int D(ptr2 P) that calls H
>>>>>>>>> int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>>>>>>>>>
>>>>>>>>> *It is much easier for people to see the infinite recursion*
>>>>>>>>> *behavior pattern when they see it actually cycle through the*
>>>>>>>>> *same instructions twice*
>>>>>>>>
>>>>>>>> Twice is not equal to infinitely. When will you see that?
>>>>>>>> It is strange that you call that an infinite recursion, when H 
>>>>>>>> aborts after two cycles and the simulated H cannot reach its own 
>>>>>>>> abort operation, because it is aborted when it had only one more 
>>>>>>>> cycle to go.
>>>>>>>> None of the aborted simulations would cycle more than twice, so 
>>>>>>>> infinite recursion is not seen for an H that aborts the 
>>>>>>>> simulation of itself.
>>>>>>>
>>>>>>> typedef void (*ptr)();
>>>>>>> int H0(ptr P);
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>>    H0(DDD);
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    H0(DDD);
>>>>>>> }
>>>>>>>
>>>>>>> _DDD()
>>>>>>> [00002172] 55               push ebp      ; housekeeping
>>>>>>> [00002173] 8bec             mov ebp,esp   ; housekeeping
>>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
>>>>>>> [0000217f] 83c404           add esp,+04
>>>>>>> [00002182] 5d               pop ebp
>>>>>>> [00002183] c3               ret
>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>
>>>>>>> The call from DDD to H0(DDD) when DDD is correctly emulated
>>>>>>> by H0 cannot possibly return.
>>>>>>
>>>>>> Contradictio in terminis. The fact that the simulated H0 does not 
>>>>>> return shows that the simulation is incorrect.
>>>>>
>>>>> void Infinite_Recursion()
>>>>> {
>>>>>    Infinite_Recursion();
>>>>> }
>>>>>
>>>>> Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
>>>>> correct simulating termination analyzer would be required to
>>>>> abort its simulation to correctly report non-terminating behavior.
>>>>> That seems quite dumb of you.
>>>>
>>>> Change of subject ignored.
>>>>
>>>>>
>>>>>> The simulated H0 does not return, because it is aborted one cycle 
>>>>>> too soon. One cycle later it would return. 
>>>>>
>>>>> Complete lack of sufficient software engineering skill.
>>>>
>>>> Maybe you should study some software engineering to get over it.
>>>>
>>>>> Unless the outermost directly executed H0 aborts its
>>>>> simulation after a fixed number of recursive invocations
>>>>> NONE OF THEM DO.
>>>>
>>>> Change of subject. We are talking about an H0 that aborts, so 
>>>> dreaming of one that does not abort is irrelevant.
>>>
>>> No one here can possibly handle more than one single point
>>> at a time without leaping to the conclusion that I must
>>> be incorrect. Because of this I will not tolerate moving
>>> beyond one single point at a time.
>>
>> You are the one that started to talk about a second point (an H0 that 
>> does not abort), when we were talking about an H0 that aborts.
>> So, I agree, let us forget about that second point (an H0 that does 
>> not abort). From now on we only talk about an H0 that aborts after two 
>> cycles. So, no infinite recursion, two cycles at most.
>>
>>>
>>>> H0 aborts after two cycles. Then it aborts the simulated H0 which at 
>>>> that moment has run only one cycle. One cycle later the simulated H0 
>>>> would also return, if not aborted.
>>>>
>>>>>
>>>>> This did baffle me for three days 3.5 years ago until
>>>>> I took the time to THINK IT ALL THE WAY THROUGH.
>>>>
>>>> Apparently, your thinking went completely wrong.
>>>>
>>>
>>> No the actual truth is that you are one of my least competent
>>> reviewers.
>>>
>>
>> Bad excuse for not showing any error in my reasoning.
> 
> I did and it was over your head.

No, you didn't.

> Unless the outer directly executed H aborts NONE-OF-THEM DO.
========== REMAINDER OF ARTICLE TRUNCATED ==========