Re: Copyright for "simulating halt decider" by Olcott for many years --- proves itself correct

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.