On 4/16/22 7:08 PM, olcott wrote:
> 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?
>
> You must show how the above input simulated by H will reach its final
> state.
>
> You must be 100% perfectly specific providing the exact execution trace
> from machine address [000009d6] ending at machine address [000009f0] of
> the correct simulation of the input to H(P,P) by H.
>
> You are not even allowed to change the integer values of the machine
> addresses.
>
> You are free to acknowledge that the correct simulation of the input to
> H(P,P) cannot possibly reach machine address [000009f0].
>

On 4/16/22 7:08 PM, olcott wrote:
> 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?
>
> You must show how the above input simulated by H will reach its final
> state.
>
> You must be 100% perfectly specific providing the exact execution trace
> from machine address [000009d6] ending at machine address [000009f0] of
> the correct simulation of the input to H(P,P) by H.
>
> You are not even allowed to change the integer values of the machine
> addresses.
>
> You are free to acknowledge that the correct simulation of the input to
> H(P,P) cannot possibly reach machine address [000009f0].
>
>
>

On 4/16/2022 6:16 PM, Dennis Bush wrote:
> On Saturday, April 16, 2022 at 7:08:36 PM UTC-4, olcott wrote:
>> 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?
>> You must show how the above input simulated by H will reach its final
>> state.
>
> So you *are* saying that only Ha can be correct

On 4/16/22 7:29 PM, olcott wrote:
> On 4/16/2022 6:16 PM, Dennis Bush wrote:
>> On Saturday, April 16, 2022 at 7:08:36 PM UTC-4, olcott wrote:
>>> 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?
>>> You must show how the above input simulated by H will reach its final
>>> state.
>>
>> So you *are* saying that only Ha can be correct
>
> I am not talking anything else in the universe besides the above machine
> code. Lets call it the 27 bytes of machine code at machine address
> [000009d6].
>

olcott <NoOne@NoWhere.com> writes:

> On 4/15/2022 5:18 PM, Ben wrote:
>> olcott <NoOne@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"

Curious that you just ignore things like that. I'd want to clear this
up -- may say I'd make a mistake or I'd changed my mind.

>>> Ĥ.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.
>
> The fact that the input to H(P,P) is non-halting is complete proof
> that H(P,P)===false is correct by logical necessity.

H(P,P)==false is correct only if P(P) is non halting, and you tell us it
is not. Changing the words gives you a glimmer of hope that you can
keep the chat going for another 18 years, but it can't obscure the fact
that you are not talking about the halting problem if H(P,P)==false for
halting P(P).

> You reasoning goes like this

You should stop paraphrasing other people. I don't ever recall you
getting it right. This may well explain a lot. If you don't know what
people are saying, you won't be able to see any of your mistakes.

--
Ben.

On 4/16/2022 7:45 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/15/2022 5:18 PM, Ben wrote:
>>> olcott <NoOne@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"
>
> Curious that you just ignore things like that. I'd want to clear this
> up -- may say I'd make a mistake or I'd changed my mind.
>
>>>> Ĥ.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.
>>
>> The fact that the input to H(P,P) is non-halting is complete proof
>> that H(P,P)===false is correct by logical necessity.
>
> H(P,P)==false is correct only if P(P) is non halting,

That is false.
H(P,P)==false is correct if an only if its input is 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

olcott <NoOne@NoWhere.com> writes:

> On 4/15/2022 5:18 PM, Ben wrote:
>> olcott <NoOne@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 that means this input is non-halting.

What is your plan? Change the words and keep repeating the mantra in
the hope that people will eventually forget that you told the world that
P(P) halts? I can't see why you would continue to use the wrong
technical terms if your purpose was to be clear, so this must be the
plan.

A couple of years ago, you knew that a C-like halt decider, H, should
return true from a call of the form H(M, I) if and only if M(I) was
finite (the term I used back then and still prefer to halting). You
(eventually) explained how you were using an alternative definition of
"halting" based on what would happen rather than what does happen.
Obviously that did not get you very far, so I can't see why you want to
bring it up again. Hiding the trick (all that remains is the word
"would") is not going to make people forget.

--
Ben.

On 4/16/2022 7:58 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/15/2022 5:18 PM, Ben wrote:
>>> olcott <NoOne@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 that means this input is non-halting.
>
> What is your plan? Change the words and keep repeating the mantra in
> the hope that people will eventually forget that you told the world that
> P(P) halts? I can't see why you would continue to use the wrong
> technical terms if your purpose was to be clear, so this must be the
> plan.
>

On 4/16/2022 7:45 PM, Ben wrote:
> H(P,P)==false is correct only if P(P) is non halting,

That requires a halt decider to compute the mapping from non-inputs on
the basis of the behavior specified by these non-inputs.

When you already know that a halt decider must compute the mapping from
its inputs on the basis of the behavior specified by these inputs, you
must know that your statement above is a lie.

--
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/22 8:54 PM, olcott wrote:
> On 4/16/2022 7:45 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/15/2022 5:18 PM, Ben wrote:
>>>> olcott <NoOne@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"
>>
>> Curious that you just ignore things like that.  I'd want to clear this
>> up -- may say I'd make a mistake or I'd changed my mind.
>>
>>>>> Ĥ.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.
>>>
>>> The fact that the input to H(P,P) is non-halting is complete proof
>>> that H(P,P)===false is correct by logical necessity.
>>
>> H(P,P)==false is correct only if P(P) is non halting,
>
> That is false.
> H(P,P)==false is correct if an only if its input is non-halting.
>

But the input P,P represents P(P).

If not, you aren't doing the Halting Problem.

Remember the requirements?

H <M> w -> Qy iff M w Halts, and -> Qn iff M w Never Halts.

If you don't look at P(P), you aren't doing the Halting Problem, and
your last 18 years are all a LIE.

On 4/16/22 9:08 PM, olcott wrote:
> On 4/16/2022 7:58 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/15/2022 5:18 PM, Ben wrote:
>>>> olcott <NoOne@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 that means this input is non-halting.
>>
>> What is your plan?  Change the words and keep repeating the mantra in
>> the hope that people will eventually forget that you told the world that
>> P(P) halts?  I can't see why you would continue to use the wrong
>> technical terms if your purpose was to be clear, so this must be the
>> plan.
>>
>
> On 4/16/2022 7:45 PM, Ben wrote:
> > H(P,P)==false is correct only if P(P) is non halting,
>
> That requires a halt decider to compute the mapping from non-inputs on
> the basis of the behavior specified by these non-inputs.
>
> When you already know that a halt decider must compute the mapping from
> its inputs on the basis of the behavior specified by these inputs, you
> must know that your statement above is a lie.
>
>

No, it requires it to try to compute the correct answer of the thing the
input represents. EXACTLU what a decider is supposed to do.

So, you just LIE about what you are doing.

BURN BABY BURN.

On 4/16/22 8:54 PM, olcott wrote:
> On 4/16/2022 7:45 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/15/2022 5:18 PM, Ben wrote:
>>>> olcott <NoOne@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"
>>
>> Curious that you just ignore things like that.  I'd want to clear this
>> up -- may say I'd make a mistake or I'd changed my mind.
>>
>>>>> Ĥ.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.
>>>
>>> The fact that the input to H(P,P) is non-halting is complete proof
>>> that H(P,P)===false is correct by logical necessity.
>>
>> H(P,P)==false is correct only if P(P) is non halting,
>
> That is false.
> H(P,P)==false is correct if an only if its input is non-halting.
>
>
>

And for a Halt Decider the behavior of the input is the behavior of the
machine the input represents.

So, you are lying again.

olcott <NoOne@NoWhere.com> writes:

> On 4/16/2022 7:45 PM, Ben wrote:
>> H(P,P)==false is correct only if P(P) is non halting,
>
> That requires a halt decider to compute the mapping from non-inputs on
> the basis of the behavior specified by these non-inputs.

No.

Would you like me to explain again? I won't bother unless you ask
nicely because you've ignored it every time I've done so before.

We never even got to the specification of TMs that decide properties of
computations because you stopped in the warm-up exercises. But unlike
some others here, I suspect you stopped because you saw the problem that
was looming, not because you couldn't do it. You could not specify P
because you could not think of a way to do that that did not refer to
what you call a "non-input"[1] and you must never admit that such
specifications are normal and, in some cases, essential. I may be
wrong, but I sometimes think you are more cunning than some people give
you credit for.

[1] There is a way to detect primes without referring to anything but
the literal string itself, but we never got to that either.
--
Ben.

olcott <NoOne@NoWhere.com> writes:

>> H(P,P)==false is correct only if P(P) is non halting,
>
> That is false.
> H(P,P)==false is correct if an only if its input is non-halting.

So do you admit that the problem of deciding what the call does is
indeed undecidable? That would be a massive step forwards.

--
Ben.

On 4/17/2022 10:09 AM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/16/2022 7:45 PM, Ben wrote:
>>> H(P,P)==false is correct only if P(P) is non halting,
>>
>> That requires a halt decider to compute the mapping from non-inputs on
>> the basis of the behavior specified by these non-inputs.
>
> No.
>
> Would you like me to explain again? I won't bother unless you ask
> nicely because you've ignored it every time I've done so before.
>

P(P) executed independently is not an input to H(P,P) that you would say
otherwise makes you a bald faced liar.

You might as well say that Trump won the election by more votes than
there are atoms in the universe.

--
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 Sunday, April 17, 2022 at 11:14:37 AM UTC-4, olcott wrote:
> On 4/17/2022 10:09 AM, Ben wrote:
> > olcott <No...@NoWhere.com> writes:
> >
> >> On 4/16/2022 7:45 PM, Ben wrote:
> >>> H(P,P)==false is correct only if P(P) is non halting,
> >>
> >> That requires a halt decider to compute the mapping from non-inputs on
> >> the basis of the behavior specified by these non-inputs.
> >
> > No.
> >
> > Would you like me to explain again? I won't bother unless you ask
> > nicely because you've ignored it every time I've done so before.
> >
> P(P) executed independently is not an input to H(P,P) that you would say
> otherwise makes you a bald faced liar.

Even if we accept that (which we don't), the input to Hb(Pa,Pa) is also the input to Ha(Pa,Pa), and the former is simulated to a final state, so the latter returning false is incorrect.

>
> You might as well say that Trump won the election by more votes than
> there are atoms in the universe.
> --
> 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 10:11 AM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>>> H(P,P)==false is correct only if P(P) is non halting,
>>
>> That is false.
>> H(P,P)==false is correct if an only if its input is non-halting.
>
> So do you admit that the problem of deciding what the call does is
> indeed undecidable? That would be a massive step forwards.
>

I admit that when you are looking for a white dog in your living room
{that the simulated input to H(P,P) halts} it is incorrect to answer
this on the basis of cats in your kitchen {the execution of P(P) halts}.

Since you already know that all deciders compute the mapping from their
inputs I don't see why you would be so ridiculously foolish to require a
decider to compute the mapping from non-inputs.

You might as well say that you are sure that dogs are a kind of cow, it
would look no less ridiculously foolish.

--
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 10:18 AM, Dennis Bush wrote:
> On Sunday, April 17, 2022 at 11:14:37 AM UTC-4, olcott wrote:
>> On 4/17/2022 10:09 AM, Ben wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>
>>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>>
>>>> That requires a halt decider to compute the mapping from non-inputs on
>>>> the basis of the behavior specified by these non-inputs.
>>>
>>> No.
>>>
>>> Would you like me to explain again? I won't bother unless you ask
>>> nicely because you've ignored it every time I've done so before.
>>>
>> P(P) executed independently is not an input to H(P,P) that you would say
>> otherwise makes you a bald faced liar.
>
> Even if we accept that (which we don't),

Ah so you too, knowing full well that the directly executed P(P) is not
an input to H(P,P) claim that it is an input even though it is not an
input?

All deciders compute the mapping from their inputs.
No decider ever computes the mapping from non-inputs.

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

>>
>> You might as well say that Trump won the election by more votes than
>> there are atoms in the universe.
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer

--
Copyright 2022 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 4/17/2022 10:09 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>
>>> That requires a halt decider to compute the mapping from non-inputs on
>>> the basis of the behavior specified by these non-inputs.
>> No.
>> Would you like me to explain again? I won't bother unless you ask
>> nicely because you've ignored it every time I've done so before.
>
> P(P) executed independently is not an input to H(P,P) that you would
> say otherwise makes you a bald faced liar.

So you don't want me to explain? OK. Stay in the dark. That works for
me because nothing makes it more certain that you won't be taken
seriously than pretending that the halting problem is not about the
computations represented by inputs.

Your problem is that you /have/ to find a way to neutralise what you
said for years about H(P,P)==false and P(P) halting. Unless you can
draw attention away from that you have nothing, but the new mantra is
not working. We remember. We remember that you tried to justify that
wrong answer by "redefining halting". We remember that false was
correct because P(P) "only halts because ..." (insert your choice to
special pleading here). We remember that false is correct "because of
what would happen if ..." (my favourite being "if line 15 were commented
out!).

--
Ben.

On 4/17/2022 10:37 AM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/17/2022 10:09 AM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>>
>>>> That requires a halt decider to compute the mapping from non-inputs on
>>>> the basis of the behavior specified by these non-inputs.
>>> No.
>>> Would you like me to explain again? I won't bother unless you ask
>>> nicely because you've ignored it every time I've done so before.
>>
>> P(P) executed independently is not an input to H(P,P) that you would
>> say otherwise makes you a bald faced liar.
>
> So you don't want me to explain? OK. Stay in the dark. That works for
> me because nothing makes it more certain that you won't be taken
> seriously than pretending that the halting problem is not about the
> computations represented by inputs.
>
> Your problem is that you /have/ to find a way to neutralise what you
> said for years about H(P,P)==false and P(P) halting. Unless you can

The fact that the correctly simulated input to H(P,P) is non-halting is
a 100% sufficient reason for H to report that its input does not halt.
That you disagree makes you a bald faced liar.

--
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/22 11:14 AM, olcott wrote:
> On 4/17/2022 10:09 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>
>>> That requires a halt decider to compute the mapping from non-inputs on
>>> the basis of the behavior specified by these non-inputs.
>>
>> No.
>>
>> Would you like me to explain again?  I won't bother unless you ask
>> nicely because you've ignored it every time I've done so before.
>>
>
> P(P) executed independently is not an input to H(P,P) that you would say
> otherwise makes you a bald faced liar.
>
> You might as well say that Trump won the election by more votes than
> there are atoms in the universe.
>

Then you have defined your program incorrect, because the input to the
Turing Machine H of <H^> <H^> DOES refer to the independently executed
H^ applied to <H^>, by DEFINITION.

You comments show that you just don't understand what Truth actually means.

On 4/17/22 11:43 AM, olcott wrote:
> On 4/17/2022 10:37 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/17/2022 10:09 AM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>>>
>>>>> That requires a halt decider to compute the mapping from non-inputs on
>>>>> the basis of the behavior specified by these non-inputs.
>>>> No.
>>>> Would you like me to explain again?  I won't bother unless you ask
>>>> nicely because you've ignored it every time I've done so before.
>>>
>>> P(P) executed independently is not an input to H(P,P) that you would
>>> say otherwise makes you a bald faced liar.
>>
>> So you don't want me to explain?  OK.  Stay in the dark.  That works for
>> me because nothing makes it more certain that you won't be taken
>> seriously than pretending that the halting problem is not about the
>> computations represented by inputs.
>>
>> Your problem is that you /have/ to find a way to neutralise what you
>> said for years about H(P,P)==false and P(P) halting.  Unless you can
>
> The fact that the correctly simulated input to H(P,P) is non-halting is
> a 100% sufficient reason for H to report that its input does not halt.
> That you disagree makes you a bald faced liar.
>

No, the INCORRECTLY simulation of the input to H(P,P) never reaches a
final state, but also never completes.

The CORRECTLY simulated input to H(P,P) will Halt if H(P,P) is false.

FAIL.

olcott <NoOne@NoWhere.com> writes:

> On 4/17/2022 10:37 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/17/2022 10:09 AM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>>>
>>>>> That requires a halt decider to compute the mapping from non-inputs on
>>>>> the basis of the behavior specified by these non-inputs.
>>>> No.
>>>> Would you like me to explain again? I won't bother unless you ask
>>>> nicely because you've ignored it every time I've done so before.
>>>
>>> P(P) executed independently is not an input to H(P,P) that you would
>>> say otherwise makes you a bald faced liar.
>> So you don't want me to explain? OK. Stay in the dark. That works for
>> me because nothing makes it more certain that you won't be taken
>> seriously than pretending that the halting problem is not about the
>> computations represented by inputs.
>>
>> Your problem is that you /have/ to find a way to neutralise what you
>> said for years about H(P,P)==false and P(P) halting. Unless you can
>
> The fact that the correctly simulated input to H(P,P) is non-halting
> is a 100% sufficient reason for H to report that its input does not
> halt. That you disagree makes you a bald faced liar.

What makes you think I disagree with that? You won't say what you mean,
or more exactly, you mean to be vague.

I had hoped you would keep telling the world that what H(M,I) should
return is not determined by whether M(I) (the "non-input") halts or not
because that makes it clear you've lost the plot!

Your new mantra hints that what M(I) does matters, without saying so,
which is, I suppose the closest you can come to telling the truth.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

olcott <NoOne@NoWhere.com> writes:

> On 4/17/2022 10:11 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>
>>> That is false.
>>> H(P,P)==false is correct if an only if its input is non-halting.
>>
>> So do you admit that the problem of deciding what the call does is
>> indeed undecidable? That would be a massive step forwards.
>>
>
> I admit that when you are looking for a white dog in your living room
> {that the simulated input to H(P,P) halts} it is incorrect to answer
> this on the basis of cats in your kitchen {the execution of P(P)
> halts}.

So you have nothing to say about the problem of deciding whether P(P)
halts? Here's the thing... You can pretend that you are considering
some other problem but the one everyone else cares about has not gone
away -- is there an function H such that H(M,I) == true if and only of
M(I) halts and false otherwise? You appear to have nothing to say about
that anymore (though there was a time when you did).

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas"
Alexandre Dumas (fils)

On 4/17/2022 7:08 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/17/2022 10:37 AM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/17/2022 10:09 AM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/16/2022 7:45 PM, Ben wrote:
>>>>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>>>>
>>>>>> That requires a halt decider to compute the mapping from non-inputs on
>>>>>> the basis of the behavior specified by these non-inputs.
>>>>> No.
>>>>> Would you like me to explain again? I won't bother unless you ask
>>>>> nicely because you've ignored it every time I've done so before.
>>>>
>>>> P(P) executed independently is not an input to H(P,P) that you would
>>>> say otherwise makes you a bald faced liar.
>>> So you don't want me to explain? OK. Stay in the dark. That works for
>>> me because nothing makes it more certain that you won't be taken
>>> seriously than pretending that the halting problem is not about the
>>> computations represented by inputs.
>>>
>>> Your problem is that you /have/ to find a way to neutralise what you
>>> said for years about H(P,P)==false and P(P) halting. Unless you can
>>
>> The fact that the correctly simulated input to H(P,P) is non-halting
>> is a 100% sufficient reason for H to report that its input does not
>> halt. That you disagree makes you a bald faced liar.
>
> What makes you think I disagree with that? You won't say what you mean,
> or more exactly, you mean to be vague.
>

So then you must agree that when H correctly simulates the input to
H(P,P) that it would never reach its own final state.

We can determine the correct simulation of this input entirely on the
basis of the following machine code and the definition of the x86 language.

_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

--

--
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 7:09 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/17/2022 10:11 AM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>> H(P,P)==false is correct only if P(P) is non halting,
>>>>
>>>> That is false.
>>>> H(P,P)==false is correct if an only if its input is non-halting.
>>>
>>> So do you admit that the problem of deciding what the call does is
>>> indeed undecidable? That would be a massive step forwards.
>>>
>>
>> I admit that when you are looking for a white dog in your living room
>> {that the simulated input to H(P,P) halts} it is incorrect to answer
>> this on the basis of cats in your kitchen {the execution of P(P)
>> halts}.
>
> So you have nothing to say about the problem of deciding whether P(P)
> halts?

As long as the input to H(P,P) is non-halting then H(P,P)==false is
necessarily correct.

This follows the general principle that when {an X is a Y} Z is
necessarily correct to report that {an X is a Y}.

_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

--
Copyright 2022 Pete Olcott

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