Path: ...!news.nobody.at!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic
Subject: Re: D correctly simulated by H cannot possibly halt --- Try to prove
 otherwise
Date: Thu, 30 May 2024 16:22:00 -0500
Organization: A noiseless patient Spider
Lines: 96
Message-ID: <v3aqlq$1rt44$1@dont-email.me>
References: <v3501h$lpnh$1@dont-email.me> <v3a3a3$1nupq$1@dont-email.me>
 <eTSdneRdKMnYCcX7nZ2dnZfqn_GdnZ2d@brightview.co.uk>
 <v3a5ha$1oamo$1@dont-email.me>
 <_BmdneCBVewsOMX7nZ2dnZfqn_adnZ2d@brightview.co.uk>
 <v3ab1i$1paor$1@dont-email.me>
 <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Thu, 30 May 2024 23:22:02 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="0a722b73a14c6c7bef786c05822a9348";
	logging-data="1963140"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/7ub+ikm58pfSwml/x0L9Y"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:a1FMMeXdYm9SQaHPgMGJD/jvHlo=
In-Reply-To: <S8CcnRadHexfe8X7nZ2dnZfqnPqdnZ2d@brightview.co.uk>
Content-Language: en-US
Bytes: 5192

On 5/30/2024 3:51 PM, Mike Terry wrote:
> On 30/05/2024 17:55, olcott wrote:

<snipped so that http://al.howardknight.net/ can see the whole message>

typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         HH(DD,DD);
12         return 0;
13       }

*TO ANYONE HAVING SUFFICIENT KNOWLEDGE OF THE C PROGRAMMING LANGUAGE*
Merely from the C source code it can be verified that DD correctly
simulated by pure simulator HH or pure function HH cannot possibly
reach its own simulated final state at line 06 and halt because
every DD remains stuck in recursive simulation the whole time that
it is correctly simulated.

_DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx
[00001c2e] e80ff7ffff call 00001342
[00001c33] 83c408     add esp,+08
[00001c36] 8945fc     mov [ebp-04],eax
[00001c39] 837dfc00   cmp dword [ebp-04],+00
[00001c3d] 7402       jz 00001c41
[00001c3f] ebfe       jmp 00001c3f
[00001c41] 8b45fc     mov eax,[ebp-04]
[00001c44] 8be5       mov esp,ebp
[00001c46] 5d         pop ebp
[00001c47] c3         ret
Size in bytes:(0038) [00001c47]


Begin Local Halt Decider Simulation   Execution Trace Stored at:113075
[00001c22][00113061][00113065] 55         push ebp
[00001c23][00113061][00113065] 8bec       mov ebp,esp
[00001c25][0011305d][00103031] 51         push ecx
[00001c26][0011305d][00103031] 8b4508     mov eax,[ebp+08]
[00001c29][00113059][00001c22] 50         push eax         ; push DD
[00001c2a][00113059][00001c22] 8b4d08     mov ecx,[ebp+08]
[00001c2d][00113055][00001c22] 51         push ecx         ; push DD
[00001c2e][00113051][00001c33] e80ff7ffff call 00001342    ; call HH
New slave_stack at:14da95
[00001c22][0015da89][0015da8d] 55         push ebp
[00001c23][0015da89][0015da8d] 8bec       mov ebp,esp
[00001c25][0015da85][0014da59] 51         push ecx
[00001c26][0015da85][0014da59] 8b4508     mov eax,[ebp+08]
[00001c29][0015da81][00001c22] 50         push eax         ; push DD
[00001c2a][0015da81][00001c22] 8b4d08     mov ecx,[ebp+08]
[00001c2d][0015da7d][00001c22] 51         push ecx         ; push DD
[00001c2e][0015da79][00001c33] e80ff7ffff call 00001342    ; call HH
Local Halt Decider: Recursive Simulation Detected Simulation Stopped


>> Merely from the C source code it can be verified that DD correctly
>> simulated by pure simulator HH or pure function HH cannot possibly
>> reach its own simulated final state at line 06 and halt because
>> every DD remains stuck in recursive simulation the whole time that
>> it is correctly simulated.
>>
>> Thus the fact that one implementation of HH is is not a pure function
>> makes no ultimate difference in this analysis and is a mere distraction
>> away from the point.
> 
> You introduced the trace into the discussion, as evidence of something.  
> But the trace is produced by a /specific/ HH/DD pair which are 
> incorrectly implemented, and so are evidence of nothing.
> 

*TO ANYONE HAVING SUFFICIENT KNOWLEDGE OF THE X86 LANGUAGE*
When you compare the x86 source code of D to the trace produced by
a blind drunk monkey you can tell that the trace is perfectly correct
because the x86 instructions specified by D are correctly simulated
and simulated in the correct order by this blind drunk monkey.


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