If the input to H(P,P) is non-halting then H(P,P)==false is necessary
correct.

Does anyone have a rebuttal to that one, or do you acknowledge that it
is correct?

You must find an example where {an X is a Y} and Z is incorrect for
reporting {an X is a Y}.

If no one can show that the correctly simulated input to H(P,P) reaches
its final state and halts that proves that it is non-halting.

If I was wrong then the correct simulation of the 27 bytes of machine
code at machine address [000009d6] by H would show some correct
execution trace from machine address [000009d6] ending at machine
address [000009f0].

_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]

That everyone refuses this challenge proves that it is beyond their
technical capacity or that they are liars.

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 11:14 PM, Dennis Bush wrote:
> On Saturday, April 16, 2022 at 11:40:20 PM UTC-4, olcott wrote:
>> If the input to H(P,P) is non-halting then H(P,P)==false is necessary
>> correct.
>
> True. *if* the input to H(P,P) is non-halting then H(P,P)==false is correct. But first we must establish whether the input to H(P,P) is non-halting.
>

I count this as excellent progress.

>>
>> Does anyone have a rebuttal to that one, or do you acknowledge that it
>> is correct?
>>
>> You must find an example where {an X is a Y} and Z is incorrect for
>> reporting {an X is a Y}.
>>
>>
>> If no one can show that the correctly simulated input to H(P,P) reaches
>> its final state and halts that proves that it is non-halting.
>>
>> If I was wrong then the correct simulation of the 27 bytes of machine
>> code at machine address [000009d6] by H would show some correct
>> execution trace from machine address [000009d6] ending at machine
>> address [000009f0].
>>
>> _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]
>
> Since an H that never aborts is an uninteresting case,
We simply hypothesize BOTH cases:
(a) aborted and
(b) never aborted
and then see where their execution traces would be.

The execution trace of both the aborted and not aborted paths is from
from machine address [000009d6] ending at machine address [0000009e1].

Therefore the simulated input to H(P,P) never makes it to [000009f0] and
halts.

--
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/17/2022 1:58 PM, Dennis Bush wrote:
> On Sunday, April 17, 2022 at 2:55:12 PM UTC-4, olcott wrote:
>> On 4/17/2022 1:47 PM, Dennis Bush wrote:
>>> On Sunday, April 17, 2022 at 2:43:00 PM UTC-4, olcott wrote:
>>>> On 4/17/2022 1:38 PM, Dennis Bush wrote:
>>>>> On Sunday, April 17, 2022 at 2:33:01 PM UTC-4, olcott wrote:
>>>>>> On 4/17/2022 1:26 PM, Dennis Bush wrote:
>>>>>>> On Sunday, April 17, 2022 at 2:07:15 PM UTC-4, olcott wrote:
>>>>>>>> On 4/17/2022 12:35 PM, Dennis Bush wrote:
>>>>>>>>> On Sunday, April 17, 2022 at 12:23:16 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/17/2022 11:12 AM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, April 17, 2022 at 12:06:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 4/17/2022 10:59 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, April 17, 2022 at 11:49:56 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 4/17/2022 10:41 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, April 17, 2022 at 11:25:37 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 4/17/2022 10:11 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, April 17, 2022 at 12:26:51 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/16/2022 11:14 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Saturday, April 16, 2022 at 11:40:20 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> If the input to H(P,P) is non-halting then H(P,P)==false is necessary
>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> True. *if* the input to H(P,P) is non-halting then H(P,P)==false is correct. But first we must establish whether the input to H(P,P) is non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I count this as excellent progress.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This has never been in dispute, by me or anyone else. The fact that you think this shows how poor your reading comprehension is.
>>>>>>>>>>>>>>>> None-the-less I count this as significant progress. It may have been
>>>>>>>>>>>>>>>> nearly the first time that anyone has ever agreed with anything that I
>>>>>>>>>>>>>>>> have ever said in this forum.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Does anyone have a rebuttal to that one, or do you acknowledge that it
>>>>>>>>>>>>>>>>>>>> is correct?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You must find an example where {an X is a Y} and Z is incorrect for
>>>>>>>>>>>>>>>>>>>> reporting {an X is a Y}.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If no one can show that the correctly simulated input to H(P,P) reaches
>>>>>>>>>>>>>>>>>>>> its final state and halts that proves that it is non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If I was wrong then the correct simulation of the 27 bytes of machine
>>>>>>>>>>>>>>>>>>>> code at machine address [000009d6] by H would show some correct
>>>>>>>>>>>>>>>>>>>> execution trace from machine address [000009d6] ending at machine
>>>>>>>>>>>>>>>>>>>> address [000009f0].
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _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 // 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]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Since an H that never aborts is an uninteresting case,
>>>>>>>>>>>>>>>>>> We simply hypothesize BOTH cases:
>>>>>>>>>>>>>>>>>> (a) aborted and
>>>>>>>>>>>>>>>>>> (b) never aborted
>>>>>>>>>>>>>>>>>> and then see where their execution traces would be.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Those two cases means you're changing the code of H, which means that P becomes a completely different computation.
>>>>>>>>>>>>>>>> We really only need to answer this single question:
>>>>>>>>>>>>>>>> Is there any case where the correctly simulated input to H(P,P) reaches
>>>>>>>>>>>>>>>> its own machine address of [000009f0]?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H either aborts the simulation of its input or does not abort the
>>>>>>>>>>>>>>>> simulation of its input. In either case the execution trace never
>>>>>>>>>>>>>>>> extends beyond machine address [000009e1].
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus we can see that whether or not H aborts the simulation of its input
>>>>>>>>>>>>>>>> this simulated input never reaches machine address [000009f0].
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you're talking about a fixed P at a fixed address, that means you are also talking about ONE SPECIFIC H at a specific address with a fixed, unchanging algorithm.
>>>>>>>>>>>>>> No stupid I am not. I am talking about the above fixed P, and two
>>>>>>>>>>>>>> different hypothetical scenarios of H at machine address [00000826].
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you're dishonestly changing the algorithm of H to make two different P's look the same. They are not.
>>>>>>>>>>>> _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]
>>>>>>>>>>>> I am considering the behavior of the simulated P under two hypothetical
>>>>>>>>>>>> scenarios:
>>>>>>>>>>>> (1) H at machine address [00000826] aborts its simulation.
>>>>>>>>>>>> (2) H at machine address [00000826] does not abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>> So in other words you're considering the behavior of two separate unrelated computations that deceptively happen to share the same set of function names and happen to live at the same set of addresses when built separately.
>>>>>>>>>>>
>>>>>>>>>> That would be the way a God damned liar would say it.
>>>>>>>>>>
>>>>>>>>>> I am only considering the actual behavior of the simulated input to
>>>>>>>>>> H(P,P) under the two possible scenarios. In each of these two possible
>>>>>>>>>> scenarios P never reaches its own final state.
>>>>>>>>>
>>>>>>>>> In other words, you're considering whether Hn can simulate Pn to a final state, and *independently* whether Ha can simulate Pa to a final state.
>>>>>>>>>
>>>>>>>>> Pn and Pa are not the same. Pn(Pn) does not halt. Pa(Pa) halts. Hn(Pn,Pn) never stops running so it can't answer. The simulation Ha(Pa,Pa) is not simulated to a final state but the simulation Hb(Pa,Pa) *is* simulated to a final state.
>>>>>>>>>
>>>>>>>>> Therefore Ha(Pa,Pa) == false is incorrect.
>>>>>>>> I have conclusively proved that the correct simulation of the input to
>>>>>>>> H(P,P) would never reach its own final state whether or not H aborts the
>>>>>>>> simulation of its input.
>>>>>>>
>>>>>>> FALSE. At most, you have shown that no H can simulate the P built from it to a final state. This is not the same as non-halting. Just because H1(P1,P1)==false and H2(P2,P2)==false and so forth doesn't mean that they all give the correct answer.
>>>>>> If the correctly simulated input to any simulating halt decider would
>>>>>> never reach its own final state then this SHD would always be correct to
>>>>>> reject this input.
>>>>>
>>>>> So now you're back to "if X then Y" without establishing whether X is true. I.E. you made a non-statement that makes no attempt at refuting what I said.
>>>> On 4/17/2022 1:32 PM, olcott wrote:
>>>>> computation that halts … the Turing machine will halt
>>>>> whenever it enters a final state. (Linz:1990:234)
>>>> Sure that is what a God damned liar would say when they simply erase the
>>>> part that proved my point.
>>>
>>> It doesn't prove your point. My point still stands.
>>>
>>> If a simulating halt decider simulates its input to a final state, this is conclusive proof that the input is halting.
>> Yes. If the correctly simulated input to a SHD cannot reach its own
>> final state then this input is non-halting.
>> _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 correctly simulated input to H(P,P) continues to execute
>> instructions from [000009d6] to [000009e1] never reaching [000009f0].
>
> Ha(Pa,Pa) does *not* perform a correct simulation of its input because it aborts too soon. Hb(Pa,Pa) performs a correct simulation of this same input by remaining in UTM mode as it simulates its input to a final state. This conclusively proves that the input to Hb(Pa,Pa), which is the same as the input to Ha(Pa,Pa), is halting and therefore that Ha is incorrect to reject it.
>