A simulating halt decider computes the mapping from its inputs to its
own final states on the basis of the behavior of its correctly simulated
input.

All of the conventional halting problem counter-example inputs are
simply rejected by a simulating halt decider as non-halting because they
fail to meet the Linz definition of halting:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

USENET comp.theory: On 4/11/2022 3:19 PM, Malcolm McLean wrote:
> PO's idea is to have a simulator with an infinite cycle detector.
> You would achieve this by modifying a UTM, so describing it as
> a "modified UTM", or "acts like a UTM until it detects an infinite
> cycle", is reasonable. And such a machine is a fairly powerful
> halt decider. Even if the infinite cycle detector isn't very
> sophisticated, it will still catch a large subset of non-halting
> machines.

The following simplifies the syntax for the definition of the Linz
Turing machine Ĥ.

There is no need for the infinite loop after H.qy because it is never
reached.

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would reach its own final
state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would never reach its own
final state.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating: (unless their simulation is aborted)
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

Since we can see that the simulated input: ⟨Ĥ0⟩ to H would never reach
its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is non-halting.

Here is the same thing that has all of the missing Linz ⊢* wildcard
state transitions filled in by fully operational code. H uses an x86
emulator to simulate its input one x86 instruction at a time.

void P(u32 x)
{ if (H(x, x)) //
HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[000009d6](01) 55 push ebp
[000009d7](02) 8bec mov ebp,esp
[000009d9](03) 8b4508 mov eax,[ebp+08]
[000009dc](01) 50 push eax // push P
[000009dd](03) 8b4d08 mov ecx,[ebp+08]
[000009e0](01) 51 push ecx // push P
[000009e1](05) e840feffff call 00000826 // call H
[000009e6](03) 83c408 add esp,+08
[000009e9](02) 85c0 test eax,eax
[000009eb](02) 7402 jz 000009ef
[000009ed](02) ebfe jmp 000009ed
[000009ef](01) 5d pop ebp
[000009f0](01) c3 ret // Final state
Size in bytes:(0027) [000009f0]

Begin Local Halt Decider Simulation
....[000009d6][00211368][0021136c] 55 push ebp // enter P
....[000009d7][00211368][0021136c] 8bec mov ebp,esp
....[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
....[000009dc][00211364][000009d6] 50 push eax // Push P
....[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][00211360][000009d6] 51 push ecx // Push P
....[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
....[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
....[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
....[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
....[000009dc][0025bd8c][000009d6] 50 push eax // Push P
....[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][0025bd88][000009d6] 51 push ecx // Push P
....[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Because the correctly simulated input to H(P,P) cannot possibly reach
its own final state at [000009f0] it is necessarily correct for H to
reject this input as non-halting.

As long as the correctly simulated input to H(P,P) would never halt then
we know it is non-halting.

Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 4/16/2022 5:43 PM, Dennis Bush wrote:
> On Saturday, April 16, 2022 at 6:33:04 PM UTC-4, olcott wrote:
>> On 4/16/2022 5:27 PM, Dennis Bush wrote:
>>> On Saturday, April 16, 2022 at 6:21:10 PM UTC-4, olcott wrote:
>>>> On 4/16/2022 5:14 PM, Dennis Bush wrote:
>>>>> On Saturday, April 16, 2022 at 5:46:07 PM UTC-4, olcott wrote:
>>>>>> On 4/16/2022 3:53 PM, Dennis Bush wrote:
>>>>>>> On Saturday, April 16, 2022 at 4:48:01 PM UTC-4, olcott wrote:
>>>>>>>> On 4/16/2022 3:39 PM, Dennis Bush wrote:
>>>>>>>>> On Saturday, April 16, 2022 at 4:22:34 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/16/2022 3:12 PM, Dennis Bush wrote:
>>>>>>>>>>> On Saturday, April 16, 2022 at 3:57:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 4/16/2022 1:50 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Saturday, April 16, 2022 at 1:41:26 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 4/16/2022 12:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 1:32:43 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 4/16/2022 12:24 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 1:02:30 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/16/2022 11:51 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 12:27:25 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/16/2022 11:23 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 12:03:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/16/2022 11:00 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 11:30:11 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/16/2022 10:17 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 10:44:29 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/16/2022 7:27 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 1:24:49 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/15/2022 5:18 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition of the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine Ĥ.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is no need for the infinite loop after H.qy because it is never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reached.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You: "No nitwit H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qy as I have told you many
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> times"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would never reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct specification is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ⊢* oo if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x)) //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You've told us that H(P,P) is false even though P(P) halts. That's the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong result for a simple model of a C halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H correctly determines that its input would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Which is doesn't.
>>>>>>>>>>>>>>>>>>>>>>>>>> LIAR LIAR PANTS ON FIRE
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The simulated input to H(P,P) cannot possibly reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>> it keeps repeating [00000956] to [00000961] until aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000956](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095c](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000960](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>> The above keeps repeating until aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096f](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00000970](01) c3 ret // final state.
>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS THE KEY STUPID AND OR DISHONEST MISTAKE OF MY REVIEWERS
>>>>>>>>>>>>>>>>>>>>>>>>>> All of my reviewers take the position that the fact that the input to
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is non-halting is not an entirely sufficient reason for H to
>>>>>>>>>>>>>>>>>>>>>>>>>> report that its input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FALSE. We reject the "fact" that the input to H(P,P) is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>> If you disagree that France exists I do not need to read the whole
>>>>>>>>>>>>>>>>>>>>>>>> message to see that you are wrong.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows the x86 language can see that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never reaches its own final state.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows the x86 language can see that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa), when given as input to Hb, DOES reach its own final state.
>>>>>>>>>>>>>>>>>>>>>> I know that Bill Jones robbed the liquor store and no amount of evidence
>>>>>>>>>>>>>>>>>>>>>> that Bill Smith didn't do it exonerates Bill Jones, Jackass.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Another bad analogy with no explanation. Again showing that you know that you're wrong and have no rebuttal.
>>>>>>>>>>>>>>>>>>>> If {an X is a Y} then anything that disagrees is incorrect.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If {an X is a Y} and Z says that {an X is a Y} then Z is necessarily
>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The problem is that you don't have an X.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> NOTHING IN THE UNIVERSE CAN POSSIBLY CORRECTLY CONTRADICT THIS:
>>>>>>>>>>>>>>>>>>>> The easily verified fact is that the input to H(P,P) is not halting
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No it's not, as proved by Hb. So prove that Hb (Pa,Pa) == true is not correct or admit defeat.
>>>>>>>>>>>>>>>>>> It is a verified fact that the input to H(P,P) is non-halting.
>>>>>>>>>>>>>>>>>> That you rebut this conclusively proves that you are a liar.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I proved that the input to Ha(Pa,Pa) does in fact halt when given to Hb.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> God damn liars continue to pretend that verified facts can be correctly
>>>>>>>>>>>>>>>> contradicted. Maybe I should put you on Thunderbird filters delete posts
>>>>>>>>>>>>>>>> from "Dennis Bush".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Still no rebuttal.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you want to be plonked?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You know that you cannot correctly contradict a verified fact thus every
>>>>>>>>>>>>>> detail of all of your dialogue is nothing but a head game.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ha and Hb are both simulating halt deciders and both are given the same input, but they get different answers. This means one must be correct and the other must be incorrect.
>>>>>>>>>>>> The easily verified fact is that the input to H(P,P) is not halting thus
>>>>>>>>>>>> H(P,P)==false is necessarily correct.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The easily verified fact is that the input to Hb(Pa,Pa), which is the same as the input to Ha(Pa,Pa) (which you call H(P,P)), DOES halt.
>>>>>>>>>> When we confirm by its x86 code that the simulated input to H(P,P) is
>>>>>>>>>> non-halting then anyone in the world that attempts to rebut this is
>>>>>>>>>> proven to be a liar.
>>>>>>>>>
>>>>>>>>> The x86 code you've shown only shows that Ha is unable to simulate its input to completion. A similar x86 trace of the same input given to Hb shows that it halts (just like the post you made a year ago that Richard recently reposted).
>>>>>>>> LIAR LIAR INCINERATED ON THE SURFACE OF THE SUN FOR ALL ETERNITY
>>>>>>>> The simulated input to H(P,P) cannot possibly reach its own final state
>>>>>>>> of [000009f0] it keeps repeating [000009d6] to [000009e1] until aborted.
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>> Because the correctly simulated input to H(P,P) cannot possibly reach
>>>>>>>> its own final state at [000009f0] it is necessarily correct for H to
>>>>>>>> reject this input as non-halting.
>>>>>>>
>>>>>>> Ha(Pa,Pa) does not correctly simulate its input. Hb(Pa,Pa) does.
>>>>>>>
>>>>>> Everyone understanding what I said knows that your attempt at rebuttal
>>>>>> is nothing more that a deceitful attempt to get away with the strawman
>>>>>> error. I know that you know this too.
>>>>>
>>>>> You've claimed that it's a strawman error numerous times but you've never stated why. At this point it just sounds like whining.
>>>>>
>>>>> You've agreed earlier that either Hb(Pa,Pa) is correct or Ha(Pa,Pa) is correct. So if Hb simulates its input to its final state, how can it possibly be wrong?
>>>> Can you show how the simulated input to H(P,P) reaches its final state?
>>>
>>> If we give the input of Ha(Pa,Pa) to Hb as Hb(Pa,Pa), it simulates for a few extra steps more than Ha does. Specifically it sees Pa call Ha, then it sees Ha return false, then it continues simulating Pa until a final state is reached.
>>>
>>> So Hb proves that the input to Ha(Pa,Pa) reaches a final state, and so the correct return value is true.
>> You must show how this input simulated by to H will reach its final
>> state, changing the subject counts as lying.
>> _P()
>> [000009d6](01) 55 push ebp
>> [000009d7](02) 8bec mov ebp,esp
>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>> [000009dc](01) 50 push eax // push P
>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>> [000009e0](01) 51 push ecx // push P
>> [000009e1](05) e840feffff call 00000826 // call H
>> [000009e6](03) 83c408 add esp,+08
>> [000009e9](02) 85c0 test eax,eax
>> [000009eb](02) 7402 jz 000009ef
>> [000009ed](02) ebfe jmp 000009ed
>> [000009ef](01) 5d pop ebp
>> [000009f0](01) c3 ret // Final state
>> Size in bytes:(0027) [000009f0]
>
> So you're saying that *only* Ha can be correct about its own simulation?

On 4/20/2022 7:11 AM, Ben wrote:
> Alex C <immibis@gmail.com> writes:
>
>> You guys might all be missing something simple: The "correct
>> simulation" does halt. So when the decider says it doesn't halt, it's
>> wrong.
>
> Who are "you guys"? I see this point being made daily. PO misses that,
> but he's not plural!
>
> And there is an even simpler point than this. PO tells us that
> H(P,P)==false "even though P(P) halts". He now denies that this is in
> anyway significant, but it's the "top-level" reason why he is wrong.
>

Why do you insist that a halt decider must compute the mapping from
non-inputs based on the behavior of these non-inputs when you already
know that this is wrong? WHY LIE ? LYING DEBASES YOURSELF !

Halt deciders must compute the mapping from inputs based on the actual
behavior of these actual inputs. The correctly simulated input to H(P,P)
never halts.

The technical computer science term "halt" means that a program will
reach its last instruction technically called its final state. For P
this would be its machine address [000009f0].

The function named H continues to simulate its input using an x86
emulator until this input either halts on its own or H detects that it
would never halt. If its input halts H returns 1. If H detects that its
input would never halt H returns 0.

void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[000009d6](01) 55 push ebp
[000009d7](02) 8bec mov ebp,esp
[000009d9](03) 8b4508 mov eax,[ebp+08]
[000009dc](01) 50 push eax // push P
[000009dd](03) 8b4d08 mov ecx,[ebp+08]
[000009e0](01) 51 push ecx // push P
[000009e1](05) e840feffff call 00000826 // call H
[000009e6](03) 83c408 add esp,+08
[000009e9](02) 85c0 test eax,eax
[000009eb](02) 7402 jz 000009ef
[000009ed](02) ebfe jmp 000009ed
[000009ef](01) 5d pop ebp
[000009f0](01) c3 ret // Final state
Size in bytes:(0027) [000009f0]

The simulated input to H(P,P) cannot possibly reach its own final state
of [000009f0] it keeps repeating [000009d6] to [000009e1] until aborted.

Begin Local Halt Decider Simulation
....[000009d6][00211368][0021136c] 55 push ebp // enter P
....[000009d7][00211368][0021136c] 8bec mov ebp,esp
....[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
....[000009dc][00211364][000009d6] 50 push eax // Push P
....[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][00211360][000009d6] 51 push ecx // Push P
....[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
....[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
....[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
....[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
....[000009dc][0025bd8c][000009d6] 50 push eax // Push P
....[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
....[000009e0][0025bd88][000009d6] 51 push ecx // Push P
....[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Because the correctly simulated input to H(P,P) cannot possibly reach
its own final state at [000009f0] it is necessarily correct for H to
reject this input as non-halting.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer