Path: ...!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: 197 page execution trace of DDD correctly simulated by HHH
Date: Fri, 28 Jun 2024 10:25:36 -0500
Organization: A noiseless patient Spider
Lines: 60
Message-ID: <v5mklg$3cibm$7@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> <v5f54f$1lp16$3@dont-email.me>
 <v5f5sd$1mcif$1@dont-email.me> <v5ght9$21jrt$1@dont-email.me>
 <v5h558$24jbd$7@dont-email.me> <v5jcas$2m18t$2@dont-email.me>
 <v5k7ju$2qsdr$5@dont-email.me> <v5mcvo$1cgj0$3@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 28 Jun 2024 17:25:37 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="8e198617313100a552662932ac49ce17";
	logging-data="3557750"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/xGRsZk51Pv0ewPQv71T4y"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:qX57BdVv1CnShQ+8V6Q9O8s8nAo=
Content-Language: en-US
In-Reply-To: <v5mcvo$1cgj0$3@i2pn2.org>
Bytes: 3893

On 6/28/2024 8:14 AM, joes wrote:
> Am Thu, 27 Jun 2024 12:30:38 -0500 schrieb olcott:
> 
>> void DDD()
>> {
>>     H0(DDD);
>> }
>>
>> int main()
>> {
>>     H0(Infinite_Loop);
>>     H0(Infinite_Recursion);
>>     H0(DDD);
>> }
> 
>> When this is construed as non-halting criteria then simulating
>> termination analyzer H0 is correct to reject these inputs as non-halting
>> by returning 0 to its caller.
> To the caller DDD, which then returns to its own caller H0, which returns
> „halting” to main… hold on.
> 
>> Simulating termination analyzers must report on the behavior that their
>> finite string input specifies thus H0 must report that DDD correctly
>> emulated by H0 remains stuck in recursive simulation.
> H0 must not report on itself, only on DDD. Which you’ve proven halts.
> We don’t care how H0 deviates (i.e. is incorrect) in its simulation.
> That would be main {H0(H0(DDD))}.

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

The call from DDD to HHH(DDD) when N steps of DDD are correctly
emulated by any pure function x86 emulator HHH cannot possibly return.

The behavior of the directly executed DDD() is irrelevant
because that is not the behavior of the input. Deciders
compute the mapping from their actual finite string input
to an output by a sequence of finite string transformations.

In this case the sequence is the line-by-line execution
trace of the behavior of DDD correctly emulated by HHH.

The behavior of this input must include and cannot ignore
the recursive emulation specified by the fact that DDD is
calling its own emulator. That people think they can just
pretend that this is not happening is ridiculous.

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