Re: Title: A Structural Analysis of the Standard Halting Problem Proof

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

On 7/25/2025 10:10 AM, joes wrote:

Am Fri, 25 Jul 2025 09:15:52 -0500 schrieb olcott:

On 7/25/2025 2:53 AM, joes wrote:

Am Thu, 24 Jul 2025 16:41:26 -0500 schrieb olcott:

On 7/24/2025 4:24 PM, joes wrote:

Am Thu, 24 Jul 2025 09:32:45 -0500 schrieb olcott:

 

Let's see: the call to HHH is #4, [waves hands], then another 4
inside the next level of simulation, and after another 4 the first
simulated HHH (the one called by the input, not the outermost
simulator. We are now 3 levels in) decides that enough is enough
and aborts,

>
Thus immediate killing its simulated DDD and everything else that
HHH was simulating thus no simulated DDD or simulated HHH can
possibly ever return no matter how many or how few X86 instructions
that the executed HHH correctly emulates.
This is the part that you fail to understand or understand that I am
correct and disagree anyway.

>

You failed to understand I was talking about the first simulated HHH
aborting, not the outermost simulator.

>
*I am trying to get you to understand that is impossible*
The only HHH that can possibly abort is the outermost directly
executed one.

>

True if the input changes along with the simulator, but not if we

>
The input is always the exact same sequence of machine language bytes.

Oh, really now? I thought it referred to its simulator HHH by name.
 

The actual code has always been based on an x86 emulator
that emulates finite strings of x86 machine code bytes.
I only refer to the C code and the names of its functions
because this code is probably too difficult for anyone here:
_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]

simulate the fixed input (that aborts after 4+4=8 instructions of DDD,
when we encounter the second nested call to HHH) without prematurely
aborting.

There exists no finite or infinite number of correctly emulated x86
instructions such that the emulated DDD ever reaches its emulated "ret"
instruction final halt state because the input to HHH(DDD) specifies
recursive emulation.

Not if DDD is simulated by something other than HHH, such as an UTM.
 

For three years everyone here acts like it is
impossible for them to understand that the correct
emulation of an input that calls its own emulator
HHH(DDD) can possibly be different then the emulation
of the same input that does not call its own emulator
HHH1(DDD).
_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer