Re: Halting Problem: What Constitutes Pathological Input

On 5/7/25 11:48 AM, olcott wrote:

On 5/7/2025 3:54 AM, Mikko wrote:

On 2025-05-06 18:05:15 +0000, olcott said:
>

That everyone here thinks that HHH can simply ignore
the rules of the x86 language and jump over the "call"
instruction to the "ret" instruction seems quite stupid
to me.

>
The halting problem does not prohibit such skip so in that sense
it is OK.
>
However, in order to correctly determine whether DD halts
it may need to know whether the called HHH returns and what it
returns if it does.
>

 The call from DD emulated by HHH cannot possibly return.

Only because HHH can't be a correct emulator.

 The recursive emulation just keep getting deeper until
HHH correctly recognizes that DD would never stop running
in the hypothetical case that this HHH never aborted.

And because it recognises that, ALL copies of DD become halting, as the correct emulation of them, which HHH has abandoned, reaches the final state.
You have decided that you hypothetical square circle has 4 corners, but of course, it turns out that it isn't a circle anymore, just like you HHH isn't a correct emulator anymore.

 

When discussing the situation we need not consider what happens
during the execution of HHH. We do know that HHH returns if it
really is a halt decider or any other decider.

 The fully operational code has shown 100% of all of
the details of this for three years.

And it proves that HHH is wrong.

 The call from DD correctly emulated by HHH to
HHH(DD) cannot possibly return. This makes the
self-contradictory part of DD unreachable.

JNo, it proves you beleive in square circles, as HHH doesn't correctly emulate its input, but you claim it does.

 

We also know that
if it returns it either returns zero or someting else. The code
of DD shows that it halts if HHH(DD) returns zero and does not
halt fi HHH(DD) returns non-zero or does not return at all.
>

 DD cannot possibly
*do the opposite of whatever value that HHH returns*
because this code is unreachable from DD correctly
emulated by HHH.
 

But HHH doesn't correctly emulate its input, so that case doesn't happen.
But DD does see the results of HHH when the input is actually correctly emulated (like with a UTM), and since THAT matches the behavior requested by the mapping of the problem, provides the correct answer, which isn't what HHH returns, so it is wrong.
All you are doing is proving you beleive in lies and equivacated definitions.