Path: ...!news-out.netnews.com!s1-2.netnews.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!nntp.club.cc.cmu.edu!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: Re: DDD correctly emulated by HHH is correctly rejected as
 non-halting.
Date: Wed, 10 Jul 2024 20:01:38 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <206f99059299030a1da8f71515e358880dec5eab@i2pn2.org>
References: <v6m7si$1uq86$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 11 Jul 2024 00:01:39 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2844748"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v6m7si$1uq86$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
X-Received-Bytes: 4835
Bytes: 5005
Lines: 91

On 7/10/24 11:03 AM, olcott wrote:
> typedef void (*ptr)();
> int HHH(ptr P);
> 
> void DDD()
> {
>    HHH(DDD);
> }
> 
> int main()
> {
>    HHH(DDD);
> }
> 
> We stipulate that the only measure of a correct emulation
> is the semantics of the x86 programming language. By this
> measure when 1 to ∞ steps of DDD are correctly emulated by
> each pure function x86 emulator HHH (of the infinite set
> of every HHH that can possibly exist) then DDD cannot
> possibly reach past its own machine address of 0000216b
> and halt.

Except that you can't stipulate what is "corrrect" or what someone else 
means by the words they used, so all you are doing is proving you aren't 
working with the normal system.

So, you are just admitting you words are meaningless for computaiton theory.

Also, since the x86 programming language DEFINES (and you didn't 
stipulate it away) that the correct behavior of an x86 proggram is that 
it runs until it reaches an end, thus the only possible "correct 
emulation" is one that doesn't stop, you CAN'T have a finite emulation 
that didn't reach a final state, so the only HHH you are alllowed is the 
one that never aborts, and thus fails to answer.

> 
> _DDD()
> [00002163] 55         push ebp      ; housekeeping
> [00002164] 8bec       mov ebp,esp   ; housekeeping
> [00002166] 6863210000 push 00002163 ; push DDD
> [0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
> [00002170] 83c404     add esp,+04
> [00002173] 5d         pop ebp
> [00002174] c3         ret
> Size in bytes:(0018) [00002174]
> 
> *This algorithm is used by the simulating termination analyzers*
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>      If simulating halt decider H correctly simulates its input D
>      until H correctly determines that its simulated D would never
>      stop running unless aborted then
> 
>      H can abort its simulation of D and correctly report that D
>      specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

And the only behavior of "correct simulation" allowed here is the actual 
correct simulation that exactly reproduces the behavior of the program 
the input represents, which means it does not EVER abort.

If HHH ever aborts its simulation, it is NOT such a simulation, nor does 
it correctly predict the behavior of such a simulation, since if 
HHH(DED) aborts its emulation and returns, then the actual behavior of 
the input, is to return, thus HHH never was correct to use the second 
paragraph.

> 
> Simulating termination analyzer HHH aborts its emulation of DDD
> as soon as it correctly detects any non-halting behavior pattern.
> At this point it aborts its emulation and returns 0 indicating
> that it rejected this input as non-halting.
> 

And thus fails to meet your stipulations, thus proving you to be a liar.

And it doesn't prove that the input, CALLING THAT SAME HHH, is 
non-halting, because by your stipuated defintion, the ONLY measure of 
the correct behavior of the input is by an actually correct emulation 
per the x86 languge specification (which isn't the one by HHH since it 
aborted) and when we give this input, that calls this HHH as defined, we 
see that it will halt when we simulate it FULLY.


You problem is you don't understand that you don't get to change HHH in 
the middle of the problem. If it does abort, it will always abort, and 
return, and thus it is never correct to say that it has correctly 
decided that it will never stop.

The fact that a DIFFERENT input, with the same code for the C function 
DDD but linked to a diffferent HHH (and thus is a different program 
represented by the input) behavies diffferently is irrelvent, as this 
DDD wasn't lonked to that over HHH.