Re: DDD correctly emulated by HHH is correctly rejected as non-halting V2

Am Wed, 31 Jul 2024 12:28:38 -0500 schrieb olcott:

On 7/31/2024 2:36 AM, Mikko wrote:

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

If the function called by DDD is not part of the input then the
input does not specify a behaviour and the question whether DDD
halts is ill-posed.

We don't care about whether HHH halts. We know that HHH halts or
fails to meet its design spec.
We are only seeing if DDD correctly emulated by HHH can can possibly
reach its own final state.

HHH does not see even that. It only sees whther that it does not
emulate DDD to its final state.

No. HHH is not judging whether or not itself is a correct emulator.

"HHH is correct when it gives the result it gives" lol

The semantics of the x86 instructions that emulates prove that its
emulation is correct.

Semantics of x86 language alone doesn't prove anything. Only a detailed
comparison of the emulator code to the x86 semantics may prove that.

*Infinite recursion behavior pattern*
An emulated sequence of instructions that has no conditional branch
instructions in this sequence is exactly repeated when it calls the same
function with the same parameters again.

Not the case here: as Mike pointed out, we are dealing with simulation,
not with calls. Furthermore, it is not the same function when the abort
is commented out or disabled by a static variable.

HHH continues to emulate DDD until DDD halts* or DDD proves that it must
be aborted. This proves that no emulated HHH can possibly return to any
emulated DDD, thus DDD never *halts.

If HHH is a decider, it halts, returning to DDD.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.