Path: ...!news.misty.com!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Copyright for "simulating halt decider" by Olcott for many years
 --- proves itself correct
Date: Sun, 2 Mar 2025 16:17:12 -0500
Organization: i2pn2 (i2pn.org)
Message-ID: <f09c7ef86be311a5fd9f27b038cd3cd5133154da@i2pn2.org>
References: <vptlfu$3st19$9@dont-email.me> <vpug3h$50td$1@dont-email.me>
 <vq06al$eljf$1@dont-email.me> <vq06ja$dfve$2@dont-email.me>
 <vq075c$eljf$3@dont-email.me> <vq08gi$f06n$1@dont-email.me>
 <vq0b4u$f3k3$4@dont-email.me> <vq0crn$fhth$2@dont-email.me>
 <vq0dl2$f3k3$10@dont-email.me> <3hg7sjhnq962dnkue9cg8ftccfbsf7rpfd@4ax.com>
 <fbc1c3d5507d1d175bdadbbfde51c10bdda1b437@i2pn2.org>
 <vq19ae$nkcf$1@dont-email.me> <vq1pbq$q7t4$1@dont-email.me>
 <vq23r8$s54f$1@dont-email.me> <vq24r7$ru20$5@dont-email.me>
 <vq2fon$ntk1$1@dont-email.me> <vq2hha$ug75$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 2 Mar 2025 21:17:13 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2553070"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <vq2hha$ug75$1@dont-email.me>
Bytes: 4944
Lines: 79

On 3/2/25 4:11 PM, olcott wrote:
> On 3/2/2025 2:40 PM, Andy Walker wrote:
>>
>>    http://www.cuboid.me.uk/anw/G12FCO/lect18.html
>>
>> [start at the third paragraph], published in 1996, wherein is the proof
>> that a simulating halt decider can no more exist than any other halt
>> decider 
> 
> [the third paragraph]
> For these cases, we can turn to our second weapon -- emulation. We want 
> to know whether a program halts, so we try it. If it halts, then we know 
> the answer. If it doesn't halt, then `it must be in a loop', so we 
> monitor its state and `detect the loop'. Sadly, although this is in one 
> sense correct, it is a false dichotomy. At any given moment as the 
> emulation proceeds, we are in one of not two but three states: the 
> program has halted, or it is looping, or it is still running and has not 
> yet entered a loop. It's the third case that kills us -- we just have to 
> keep going, and wait for one of the other two things to happen. The 
> trouble is that it may be that neither of them ever happens -- which is 
> why `it must be in a loop' was in quotes above.
> 
> _DD()
> [00002133] 55         push ebp      ; housekeeping
> [00002134] 8bec       mov ebp,esp   ; housekeeping
> [00002136] 51         push ecx      ; make space for local
> [00002137] 6833210000 push 00002133 ; push DD
> [0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
> [00002141] 83c404     add esp,+04
> [00002144] 8945fc     mov [ebp-04],eax
> [00002147] 837dfc00   cmp dword [ebp-04],+00
> [0000214b] 7402       jz 0000214f
> [0000214d] ebfe       jmp 0000214d
> [0000214f] 8b45fc     mov eax,[ebp-04]
> [00002152] 8be5       mov esp,ebp
> [00002154] 5d         pop ebp
> [00002155] c3         ret
> Size in bytes:(0035) [00002155]
> 
> That analysis is derived from an incorrect perspective.
> DD emulated by HHH according to the behavior that DD
> specifies cannot possibly reach its own "ret" instruction
> and terminate normally.


But YOUR perspective is the incorrect one, as it is againt the definitions.

Halting is a property of the Machine, and its direct execution, not can 
it be emulated by a decider.

> 
> This process computes the mapping from the actual input
> (not any other damn thing) finite string to the non
> terminating behavior that this finite specifies when
> it calls its own emulator in recursive emulation.

And the MAPPING is DEFINED to be input -> 1 if UTM(input) halts, and 
input -> 0 if UTM(input) does not halt.

If your HHH isn't a UTM, and a UTM BY DEFINITION EXACTLY reproduces the 
behavior of the input, thus can't halt if the input is non-halting, then 
its emulation doesn't matter.

> 
> Another different instance that does not call its own
> emulator in recursive emulation is not the same damn thing.
> 
> 

Which means you don't understand the fundamental property that all 
copies of a computation (program + input) do exactly the same thing, as 
they are not allowed to depend on anything other than there code and the 
input.

Your problem is that your DD isn't a program, as it doesn't include all 
its code, and you "Decider" isn't either, as it looks at memory other 
than that provided by the input, namely to see what HHH is.

Thus, your whole premsis is built on LIES and ERRORS.