Re: Proof that DD correctly simulated by HH has different behavior than DD(DD)

Op 10.jun.2024 om 21:47 schreef olcott:

On 6/10/2024 2:41 PM, Fred. Zwarts wrote:

>
That is the easiest way to ignore that it is just a proven false negative: Remove the proof and claim that it is a change of subject.

 *You did not prove that this is false you only ignored it*
*You did not prove that this is false you only ignored it*
*You did not prove that this is false you only ignored it*
   D correctly simulated by H proved for THREE YEARS ---
 *No one has verified the actual facts of this for THREE YEARS*
*No one has verified the actual facts of this for THREE YEARS*
*No one has verified the actual facts of this for THREE YEARS*
 On 5/29/2021 2:26 PM, olcott wrote:
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
 THE ONLY POSSIBLE WAY for D simulated by H to have the same
behavior as the directly executed D(D) is for the instructions
of D to be incorrectly simulated by H (details provided below).

Proven false. The direct execution does not ignore the call to H. So, to get the same behaviour, the simulation should also simulate the call. The problem is that H is required to halt and return from the call, but your H does not return as required. It can't, because it is prematurely aborted. This proves that a simulation is unable to simulate itself up to the end. This is what causes the false negatives.

 _D()
[00000cfc](01) 55          push ebp
[00000cfd](02) 8bec        mov ebp,esp
[00000cff](03) 8b4508      mov eax,[ebp+08]
[00000d02](01) 50          push eax       ; push D
[00000d03](03) 8b4d08      mov ecx,[ebp+08]
[00000d06](01) 51          push ecx       ; push D
[00000d07](05) e800feffff  call 00000b0c  ; call H
[00000d0c](03) 83c408      add esp,+08
[00000d0f](02) 85c0        test eax,eax
[00000d11](02) 7404        jz 00000d17
[00000d13](02) 33c0        xor eax,eax
[00000d15](02) eb05        jmp 00000d1c
[00000d17](05) b801000000  mov eax,00000001
[00000d1c](01) 5d          pop ebp
[00000d1d](01) c3          ret
Size in bytes:(0034) [00000d1d]

Olcott has shown this and similar code, both in C as in x86 code for several years now. He was never able to prove the claim that it never reaches past the call at 00000d07. He thinks that he needs an expert in C or x86 to give the proof. So he has been begging desperately for years in several newsgroups if an expert can show the proof. This has never resulted in a proof. In fact most reactions from the experts are that such a proof is impossible because the requirements for H are unclear.
Olcott wants contradicting requirements for H. At the one hand he wants H to halt and, therefore, to return to its caller, at the other hand he wants a proof that H, called at 0000d07 does not return to its caller.
It is a great puzzle for me why he keeps believing in these contradictory properties of H. If he could prove that the call at 0000d07 does not return, he would prove at the same time that H is not a halting function, violating its requirement.
My interest is no longer in the computation theory behind this question, but in the psychological aspect. How is it possible that somewhat wants to prove that a H with contradictory properties exists?
The only reason I can think of, is that he has spent so many years in this subject, that he is unable to see the truth. He is unable to read and to grasp the proof and stays in rebuttal mode, without even considering for one moment that he could be wrong.