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.

Any simulating halt decider that simulates its input to its own final state is necessarily correct because the decider never leaves UTM mode. This means that Hb(Pa,Pa) == true is correct, therefore Ha(Pa,Pa) == false is wrong.

THAT is a verified fact.

On 4/16/22 1:02 PM, 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.
>
>

No, it isn't.

YOU vefified that it Halts. Remembet this?

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

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.

On 4/16/22 1:32 PM, 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".

On 4/16/22 1:41 PM, 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.

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.
>

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.

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.

On 4/16/22 3:57 PM, 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 H(P,P) is not halting thus
> H(P,P)==false is necessarily correct.
>
> 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 H(P,P) is not halting thus
> H(P,P)==false is necessarily correct.
>
> The easily verified fact is that the input to H(P,P) is not halting thus
> H(P,P)==false is necessarily correct.
>
>

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.

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.

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

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.

On 4/16/22 4:47 PM, 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.
>
>
>

On 4/16/22 4:22 PM, 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.

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.

On 4/16/22 5:45 PM, 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.
>
> This may be the last time that I respond to you.
>

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.

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?

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?

On 4/16/22 6:21 PM, 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?
>
>

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.

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]

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

On 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.