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
Subject: Re: Because Olcott has made this error 500 times in the last three
 years...
Date: Fri, 26 Jul 2024 15:53:57 +0200
Organization: A noiseless patient Spider
Lines: 193
Message-ID: <v809pm$2rou5$1@dont-email.me>
References: <v7uvbq$2h6oq$1@dont-email.me> <v7vh4j$2ndo6$1@dont-email.me>
 <v807vd$2rabc$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 26 Jul 2024 15:53:59 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="61dd50ac79df5a1cde36cf94e230b0d4";
	logging-data="3007429"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+zwxmKkZ73xhLFJZPZJfmB"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:hpXfUIH85IqfaRpgC9IK8pLBgIs=
Content-Language: en-GB
In-Reply-To: <v807vd$2rabc$2@dont-email.me>
Bytes: 9583

Op 26.jul.2024 om 15:22 schreef olcott:
> On 7/26/2024 1:53 AM, Fred. Zwarts wrote:
>> Op 26.jul.2024 om 03:49 schreef olcott:
>>> If you understand the x86 language and can't tell how DDD
>>> emulated by HHH differs from DDD emulated by HHH1 by the
>>> following then you are probably lying about understanding
>>> the x86 language.
>>
>> We understand it perfectly. HHH cannot possibly simulate itself 
>> correctly.
> 
> You are too stupid to know that a non-halting computation
> cannot be emulated to completion because completion does
> not exist.

The non-halting behaviour is only in your dreams. It is irrelevant, 
because HHH halts when it aborts. Remember, HHH is simulating *itself*, 
a halting program, not another non-halting simulator that does not abort 
and does not halt.

> 
> On this stupid basis you say that because HHH does not simulate
> DDD to a completion that does not exist that DDD is simulated
> incorrectly. Unlike pure ad hominem rebuttals I point out how
> and why what you say is stupidly incorrect.

Since you do not understand that there is a difference between two and 
infinite, you think that there is an infinite recursion (non-halting) 
that must be halted. But the non-halting behaviour is just your dream.
You are unable to see the difference between your dream and reality.

The semantics of the x86 language of this code show, when directly 
executed, that there is no non-halting behaviour. HHH halts after two 
cycles. This semantics does not change when we give the exact same code 
to a correct simulator, like HHH1, which also shows that it halts after 
two cycles.

The semantics of the x86 language does not change when we give the exact 
same code to an incorrect simulator, like HHH, but HHH fails to properly 
simulate this code up to the end, because it aborts the simulation after 
one cycle, when the simulation still has one cycle to go, proving that 
the simulation is incomplete and incorrect. It shows only the first part 
of the behaviour of HHH, not its full behaviour.

Two is different from infinite. One is different from infinite.

If you think this is stupid, it tells us more about you, than about this 
reasoning. You do not have the mental intelligence to even consider the 
possibility that you are wrong, therefore, if you cannot point to an 
error, you just ignore it using the excuse that it is stupid or untrue 
what people tell you.

HHH is simply unable to decide about finite recursions.

void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}

This is a similar finite recursion as that of HHH, which halts after two 
cycles.
It decides after two recursions that there is an infinite recursion, 
which is incorrect.

> 
>> HH1 does a correct simulation, but HHH does an incomplete and 
>> therefore incorrect simulation. The incomplete simulation does not 
>> show the full behaviour of DDD.
>> Since skipping x86 code is against the semantics of the x86 language, 
>> it is clear where the error is.
>>
>>>
>>> *I did annotate it a little better this time*
>>>
>>> typedef void (*ptr)();
>>> int HHH(ptr P);
>>> int HHH1(ptr P);
>>>
>>> void DDD()
>>> {
>>>    HHH(DDD);
>>> }
>>>
>>> int main()
>>> {
>>>    HHH1(DDD);
>>> }
>>>
>>> *You really don't need to know one damn thing else besides this*
>>> *You really don't need to know one damn thing else besides this*
>>> *You really don't need to know one damn thing else besides this*
>>>
>>> All that you have to know is that HHH and HHH1 are x86 emulators
>>> and that HHH sees that same repeated state (first four lines of DDD)
>>> that anyone knowing the x86 language can see.
>>>
>>> _DDD()
>>> [00002177] 55         push ebp
>>> [00002178] 8bec       mov ebp,esp
>>> [0000217a] 6877210000 push 00002177 ; push DDD
>>> [0000217f] e853f4ffff call 000015d7 ; call HHH
>>> [00002184] 83c404     add esp,+04
>>> [00002187] 5d         pop ebp
>>> [00002188] c3         ret
>>> Size in bytes:(0018) [00002188]
>>>
>>> _main()
>>> [00002197] 55         push ebp
>>> [00002198] 8bec       mov ebp,esp
>>> [0000219a] 6877210000 push 00002177 ' push DDD
>>> [0000219f] e863f3ffff call 00001507 ; call HH1
>>> [000021a4] 83c404     add esp,+04
>>> [000021a7] 33c0       xor eax,eax
>>> [000021a9] 5d         pop ebp
>>> [000021aa] c3         ret
>>> Size in bytes:(0020) [000021aa]
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00002197][001037fb][00000000] 55         push ebp
>>> [00002198][001037fb][00000000] 8bec       mov ebp,esp
>>> [0000219a][001037f7][00002177] 6877210000 push 00002177 ; push DDD
>>> [0000219f][001037f3][000021a4] e863f3ffff call 00001507 ; call HHH1
>>> New slave_stack at:10389f
>>>
>>> // emulates 1st instance of DDD that calls HHH(DDD)
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138a7
>>> [00002177][00113897][0011389b] 55         push ebp
>>> [00002178][00113897][0011389b] 8bec       mov ebp,esp
>>> [0000217a][00113893][00002177] 6877210000 push 00002177 ; push DDD
>>> [0000217f][0011388f][00002184] e853f4ffff call 000015d7 ; call HHH
>>> New slave_stack at:14e2c7
>>>
>>> // emulates 2nd instance of DDD that calls HHH(DDD)
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2cf
>>> [00002177][0015e2bf][0015e2c3] 55         push ebp
>>> [00002178][0015e2bf][0015e2c3] 8bec       mov ebp,esp
>>> [0000217a][0015e2bb][00002177] 6877210000 push 00002177 ; push DDD
>>> [0000217f][0015e2b7][00002184] e853f4ffff call 000015d7 ; call HHH
>>> New slave_stack at:198cef
>>>
>>> // emulates 3rd instance of DDD that calls HHH(DDD)
>>> [00002177][001a8ce7][001a8ceb] 55         push ebp
>>> [00002178][001a8ce7][001a8ceb] 8bec       mov ebp,esp
>>> [0000217a][001a8ce3][00002177] 6877210000 push 00002177 ; push DDD
>>> [0000217f][001a8cdf][00002184] e853f4ffff call 000015d7 ; call HHH
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> This is the error in HHH. HHH is programmed to print after two cycles 
>> that there is an infinite recursion, which is not true, after which it 
>> aborts and halts, making the simulation incorrect.
>>
>> HHH is simply unable to decide about finite recursions.
>>
>> void Finite_Recursion (int N) {
>>    if (N > 0) Finite_Recursion (N - 1);
>> }
>>
>> It decides after N recursions that there is an infinite recursion, 
>> which is incorrect. It does not see the difference between an finite 
>> and an infinite recursion.
>>
>>>
>>> // returns to 1st instance of DDD emulated by HHH1
>>> [00002184][00113897][0011389b] 83c404     add esp,+04
>>> [00002187][0011389b][000015bc] 5d         pop ebp
>>> [00002188][0011389f][0003a980] c3         ret
>>>
>>> // return to main
>>> [000021a4][001037fb][00000000] 83c404     add esp,+04
>>> [000021a7][001037fb][00000000] 33c0       xor eax,eax
>>> [000021a9][001037ff][00000018] 5d         pop ebp
>>> [000021aa][00103803][00000000] c3         ret
>>> Number of Instructions Executed(352831) == 5266 Pages
>>>
>> Olcott's psychology is intriguing. At the one hand he is crying for 
>> help. He has some ideas which he cannot prove. Therefore he is begging 
========== REMAINDER OF ARTICLE TRUNCATED ==========