On 8/17/2022 8:36 PM, Richard Damon wrote:
> On 8/17/22 9:12 PM, olcott wrote:
>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>> On 8/17/22 11:08 AM, olcott wrote:
>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> So you are saying that the correct and complete x86 emulation
>>>>>>>>>> by H(P,P)
>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>
>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>> H is a C function that I hope to show is a valid proxy for TM at
>>>>>>>> some
>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>> software
>>>>>>>> engineering.
>>>>>>>>
>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>> much wider
>>>>>>>> audience.
>>>>>>>>
>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>
>>>>>> H is a C function, not a program and I made it as Turing
>>>>>> equivalent as I could. H always returns the same value for the
>>>>>> same arguments every time that it is invoked.
>>>>>
>>>>> And this is a key part of your error.
>>>>
>>>> H(P,P) does correctly determine that its input never halts there is
>>>> no error in this.
>>>
>>> Nope, you have shown that it halts.
>> I have shown that the input simulated by H(P,P) reaches the "return"
>> instruction (final state of this input?
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>>
>>
>
> You have shown that the CORRECT (and complete) simulation of the input
> to H(P,P) will Halt.
>

I have shown that the CORRECT (and complete) simulation of the input
to H(P,P) *BY H* will Halt
*MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
(final state) ???

--
Copyright 2022 Pete Olcott

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

On 8/17/22 10:14 PM, olcott wrote:
> On 8/17/2022 8:36 PM, Richard Damon wrote:
>> On 8/17/22 9:12 PM, olcott wrote:
>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> So you are saying that the correct and complete x86 emulation
>>>>>>>>>>> by H(P,P)
>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>
>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>> H is a C function that I hope to show is a valid proxy for TM
>>>>>>>>> at some
>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>> software
>>>>>>>>> engineering.
>>>>>>>>>
>>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>>> much wider
>>>>>>>>> audience.
>>>>>>>>>
>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>
>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>> equivalent as I could. H always returns the same value for the
>>>>>>> same arguments every time that it is invoked.
>>>>>>
>>>>>> And this is a key part of your error.
>>>>>
>>>>> H(P,P) does correctly determine that its input never halts there is
>>>>> no error in this.
>>>>
>>>> Nope, you have shown that it halts.
>>> I have shown that the input simulated by H(P,P) reaches the "return"
>>> instruction (final state of this input?
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>>
>>>
>>
>> You have shown that the CORRECT (and complete) simulation of the input
>> to H(P,P) will Halt.
>>
> I have shown that the CORRECT (and complete) simulation of the input
> to H(P,P) *BY H* will Halt
> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
> (final state)
>
Except that the only H that actually does this BY DEFINITION doesn't
abort its simulaiton and thus doesn't answer.

The H that does abort its simulation, doesn't do a COMPLETE simulation,
and thus can't use itself as a proof that it is right, Since BY
DEFINITION P uses the exact same H as the one that is deciding it, H is
INCORRECT to use the attribute of the DIFFERENT H mentioned in the
previous paragraph.

Note, the DEFINITION of "Halting" is NOT that the simulaiton by the
decider reaches a final state, but that the machine the input represents
reaches a final state, and it does if H(P,P) returns 0.

Thus, you have only shown that H is a correct POOP decider, not a Halt
Decider, and that you are either a pathological liar or a total idiot.

On 8/17/2022 9:32 PM, Richard Damon wrote:
> On 8/17/22 10:14 PM, olcott wrote:
>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>> On 8/17/22 9:12 PM, olcott wrote:
>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>
>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>> H is a C function that I hope to show is a valid proxy for TM
>>>>>>>>>> at some
>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>>> software
>>>>>>>>>> engineering.
>>>>>>>>>>
>>>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>>>> much wider
>>>>>>>>>> audience.
>>>>>>>>>>
>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>
>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>> equivalent as I could. H always returns the same value for the
>>>>>>>> same arguments every time that it is invoked.
>>>>>>>
>>>>>>> And this is a key part of your error.
>>>>>>
>>>>>> H(P,P) does correctly determine that its input never halts there
>>>>>> is no error in this.
>>>>>
>>>>> Nope, you have shown that it halts.
>>>> I have shown that the input simulated by H(P,P) reaches the "return"
>>>> instruction (final state of this input?
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>>
>>>>
>>>
>>> You have shown that the CORRECT (and complete) simulation of the
>>> input to H(P,P) will Halt.
>>>
>> I have shown that the CORRECT (and complete) simulation of the input
>> to H(P,P) *BY H* will Halt
>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>> (final state)
>>
> Except that the only H that actually does this BY DEFINITION doesn't
> abort its simulaiton and thus doesn't answer.
>

On 8/17/2022 8:36 PM, Richard Damon wrote:
> You have shown that the CORRECT (and complete) simulation of the input
> to H(P,P) will Halt.

I have never shown anything like this.

--
Copyright 2022 Pete Olcott

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

On 8/17/22 10:47 PM, olcott wrote:
> On 8/17/2022 9:32 PM, Richard Damon wrote:
>> On 8/17/22 10:14 PM, olcott wrote:
>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>> On 8/17/22 9:12 PM, olcott wrote:
>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>
>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for TM
>>>>>>>>>>> at some
>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>>>> software
>>>>>>>>>>> engineering.
>>>>>>>>>>>
>>>>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>>>>> much wider
>>>>>>>>>>> audience.
>>>>>>>>>>>
>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>>
>>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>>> equivalent as I could. H always returns the same value for the
>>>>>>>>> same arguments every time that it is invoked.
>>>>>>>>
>>>>>>>> And this is a key part of your error.
>>>>>>>
>>>>>>> H(P,P) does correctly determine that its input never halts there
>>>>>>> is no error in this.
>>>>>>
>>>>>> Nope, you have shown that it halts.
>>>>> I have shown that the input simulated by H(P,P) reaches the
>>>>> "return" instruction (final state of this input?
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>>
>>>>>
>>>>
>>>> You have shown that the CORRECT (and complete) simulation of the
>>>> input to H(P,P) will Halt.
>>>>
>>> I have shown that the CORRECT (and complete) simulation of the input
>>> to H(P,P) *BY H* will Halt
>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>>> (final state)
>>>
>> Except that the only H that actually does this BY DEFINITION doesn't
>> abort its simulaiton and thus doesn't answer.
>>
>
> On 8/17/2022 8:36 PM, Richard Damon wrote:
> > You have shown that the CORRECT (and complete) simulation of the input
> > to H(P,P) will Halt.
>
> I have never shown anything like this.
>
>

Then what is this, but a trace of x86UTM simulating the input that you
give to H(P,P) just in this case you called P H_Hat.

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

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)

On 8/17/2022 10:01 PM, Richard Damon wrote:
> On 8/17/22 10:47 PM, olcott wrote:
>> On 8/17/2022 9:32 PM, Richard Damon wrote:
>>> On 8/17/22 10:14 PM, olcott wrote:
>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>> On 8/17/22 9:12 PM, olcott wrote:
>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
>>>>>>>>>>>> TM at some
>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>>>>> software
>>>>>>>>>>>> engineering.
>>>>>>>>>>>>
>>>>>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>>>>>> much wider
>>>>>>>>>>>> audience.
>>>>>>>>>>>>
>>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>>>
>>>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>>>> equivalent as I could. H always returns the same value for the
>>>>>>>>>> same arguments every time that it is invoked.
>>>>>>>>>
>>>>>>>>> And this is a key part of your error.
>>>>>>>>
>>>>>>>> H(P,P) does correctly determine that its input never halts there
>>>>>>>> is no error in this.
>>>>>>>
>>>>>>> Nope, you have shown that it halts.
>>>>>> I have shown that the input simulated by H(P,P) reaches the
>>>>>> "return" instruction (final state of this input?
>>>>>>
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters a final state. (Linz:1990:234)
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> You have shown that the CORRECT (and complete) simulation of the
>>>>> input to H(P,P) will Halt.
>>>>>
>>>> I have shown that the CORRECT (and complete) simulation of the input
>>>> to H(P,P) *BY H* will Halt
>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>>>> (final state)
>>>>
>>> Except that the only H that actually does this BY DEFINITION doesn't
>>> abort its simulaiton and thus doesn't answer.
>>>
>>
>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>  > You have shown that the CORRECT (and complete) simulation of the input
>>  > to H(P,P) will Halt.
>>
>> I have never shown anything like this.
>>
>>
>
> Then what is this, but a trace of x86UTM simulating the input that you
> give to H(P,P) just in this case you called P H_Hat.
>
> 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
>
> Above decision was from the call the Halts inside H_Hat, deciding that
> H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
> processed below:
>
> > ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
> > ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
> > ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword [ebp-04],+00
> > ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
> > ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
> > ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
> > ...[00000bba][001015d0][00000b98](01)  c3         ret
> > ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
> > ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
> > ...[00000bda][001015d8][00100000](01)  5d         pop ebp
> > ...[00000bdb][001015dc][00000098](01)  c3         ret
>
> SEE IT HALTED!
>
> > Number_of_User_Instructions(39)
> > Number of Instructions Executed(26567)
>

On Wednesday, August 17, 2022 at 11:17:16 PM UTC-4, olcott wrote:
> On 8/17/2022 10:01 PM, Richard Damon wrote:
> > On 8/17/22 10:47 PM, olcott wrote:
> >> On 8/17/2022 9:32 PM, Richard Damon wrote:
> >>> On 8/17/22 10:14 PM, olcott wrote:
> >>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
> >>>>> On 8/17/22 9:12 PM, olcott wrote:
> >>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
> >>>>>>> On 8/17/22 11:08 AM, olcott wrote:
> >>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
> >>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
> >>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
> >>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> So you are saying that the correct and complete x86
> >>>>>>>>>>>>>> emulation by H(P,P)
> >>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
> >>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
> >>>>>>>>>>>> TM at some
> >>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
> >>>>>>>>>>>> software
> >>>>>>>>>>>> engineering.
> >>>>>>>>>>>>
> >>>>>>>>>>>> I am biding my time here while I am preparing the code for a
> >>>>>>>>>>>> much wider
> >>>>>>>>>>>> audience.
> >>>>>>>>>>>>
> >>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine..
> >>>>>>>>>>
> >>>>>>>>>> H is a C function, not a program and I made it as Turing
> >>>>>>>>>> equivalent as I could. H always returns the same value for the
> >>>>>>>>>> same arguments every time that it is invoked.
> >>>>>>>>>
> >>>>>>>>> And this is a key part of your error.
> >>>>>>>>
> >>>>>>>> H(P,P) does correctly determine that its input never halts there
> >>>>>>>> is no error in this.
> >>>>>>>
> >>>>>>> Nope, you have shown that it halts.
> >>>>>> I have shown that the input simulated by H(P,P) reaches the
> >>>>>> "return" instruction (final state of this input?
> >>>>>>
> >>>>>> computation that halts … the Turing machine will halt whenever it
> >>>>>> enters a final state. (Linz:1990:234)
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>
> >>>>> You have shown that the CORRECT (and complete) simulation of the
> >>>>> input to H(P,P) will Halt.
> >>>>>
> >>>> I have shown that the CORRECT (and complete) simulation of the input
> >>>> to H(P,P) *BY H* will Halt
> >>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
> >>>> (final state)
> >>>>
> >>> Except that the only H that actually does this BY DEFINITION doesn't
> >>> abort its simulaiton and thus doesn't answer.
> >>>
> >>
> >> On 8/17/2022 8:36 PM, Richard Damon wrote:
> >> > You have shown that the CORRECT (and complete) simulation of the input
> >> > to H(P,P) will Halt.
> >>
> >> I have never shown anything like this.
> >>
> >>
> >
> > Then what is this, but a trace of x86UTM simulating the input that you
> > give to H(P,P) just in this case you called P H_Hat.
> >
> > On 4/27/21 12:55 AM, olcott wrote:
> > Message-ID: <Teudndbu59GVBBr9...@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
> >
> > Above decision was from the call the Halts inside H_Hat, deciding that
> > H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
> > processed below:
> >
> > > ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> > > ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> > > ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> > > ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> > > ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> > > ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> > > ...[00000bba][001015d0][00000b98](01) c3 ret
> > > ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> > > ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> > > ...[00000bda][001015d8][00100000](01) 5d pop ebp
> > > ...[00000bdb][001015dc][00000098](01) c3 ret
> >
> > SEE IT HALTED!
> >
> > > Number_of_User_Instructions(39)
> > > Number of Instructions Executed(26567)
> >
> The input simulated H(P,P) never halts.

On 8/17/22 11:17 PM, olcott wrote:
> On 8/17/2022 10:01 PM, Richard Damon wrote:
>> On 8/17/22 10:47 PM, olcott wrote:
>>> On 8/17/2022 9:32 PM, Richard Damon wrote:
>>>> On 8/17/22 10:14 PM, olcott wrote:
>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>>> On 8/17/22 9:12 PM, olcott wrote:
>>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
>>>>>>>>>>>>> TM at some
>>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>>>>>> software
>>>>>>>>>>>>> engineering.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am biding my time here while I am preparing the code for
>>>>>>>>>>>>> a much wider
>>>>>>>>>>>>> audience.
>>>>>>>>>>>>>
>>>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>>>>
>>>>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>>>>> equivalent as I could. H always returns the same value for
>>>>>>>>>>> the same arguments every time that it is invoked.
>>>>>>>>>>
>>>>>>>>>> And this is a key part of your error.
>>>>>>>>>
>>>>>>>>> H(P,P) does correctly determine that its input never halts
>>>>>>>>> there is no error in this.
>>>>>>>>
>>>>>>>> Nope, you have shown that it halts.
>>>>>>> I have shown that the input simulated by H(P,P) reaches the
>>>>>>> "return" instruction (final state of this input?
>>>>>>>
>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> You have shown that the CORRECT (and complete) simulation of the
>>>>>> input to H(P,P) will Halt.
>>>>>>
>>>>> I have shown that the CORRECT (and complete) simulation of the input
>>>>> to H(P,P) *BY H* will Halt
>>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>>>>> (final state)
>>>>>
>>>> Except that the only H that actually does this BY DEFINITION doesn't
>>>> abort its simulaiton and thus doesn't answer.
>>>>
>>>
>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>  > You have shown that the CORRECT (and complete) simulation of the
>>> input
>>>  > to H(P,P) will Halt.
>>>
>>> I have never shown anything like this.
>>>
>>>
>>
>> Then what is this, but a trace of x86UTM simulating the input that you
>> give to H(P,P) just in this case you called P H_Hat.
>>
>> 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
>>
>> Above decision was from the call the Halts inside H_Hat, deciding that
>> H_Hat(H_Hat) seems to be non-halting, it then returns that answer and
>> is processed below:
>>
>>  > ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
>>  > ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
>>  > ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword
>> [ebp-04],+00
>>  > ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
>>  > ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
>>  > ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
>>  > ...[00000bba][001015d0][00000b98](01)  c3         ret
>>  > ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
>>  > ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
>>  > ...[00000bda][001015d8][00100000](01)  5d         pop ebp
>>  > ...[00000bdb][001015dc][00000098](01)  c3         ret
>>
>> SEE IT HALTED!
>>
>>  > Number_of_User_Instructions(39)
>>  > Number of Instructions Executed(26567)
>>
>
> The input simulated H(P,P) never halts.
>

On 8/17/2022 10:24 PM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 11:17:16 PM UTC-4, olcott wrote:
>> On 8/17/2022 10:01 PM, Richard Damon wrote:
>>> On 8/17/22 10:47 PM, olcott wrote:
>>>> On 8/17/2022 9:32 PM, Richard Damon wrote:
>>>>> On 8/17/22 10:14 PM, olcott wrote:
>>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>>>> On 8/17/22 9:12 PM, olcott wrote:
>>>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
>>>>>>>>>>>>>> TM at some
>>>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>>>>>>> software
>>>>>>>>>>>>>> engineering.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>>>>>>>> much wider
>>>>>>>>>>>>>> audience.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>>>>>
>>>>>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>>>>>> equivalent as I could. H always returns the same value for the
>>>>>>>>>>>> same arguments every time that it is invoked.
>>>>>>>>>>>
>>>>>>>>>>> And this is a key part of your error.
>>>>>>>>>>
>>>>>>>>>> H(P,P) does correctly determine that its input never halts there
>>>>>>>>>> is no error in this.
>>>>>>>>>
>>>>>>>>> Nope, you have shown that it halts.
>>>>>>>> I have shown that the input simulated by H(P,P) reaches the
>>>>>>>> "return" instruction (final state of this input?
>>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> You have shown that the CORRECT (and complete) simulation of the
>>>>>>> input to H(P,P) will Halt.
>>>>>>>
>>>>>> I have shown that the CORRECT (and complete) simulation of the input
>>>>>> to H(P,P) *BY H* will Halt
>>>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>>>>>> (final state)
>>>>>>
>>>>> Except that the only H that actually does this BY DEFINITION doesn't
>>>>> abort its simulaiton and thus doesn't answer.
>>>>>
>>>>
>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>> > You have shown that the CORRECT (and complete) simulation of the input
>>>> > to H(P,P) will Halt.
>>>>
>>>> I have never shown anything like this.
>>>>
>>>>
>>>
>>> Then what is this, but a trace of x86UTM simulating the input that you
>>> give to H(P,P) just in this case you called P H_Hat.
>>>
>>> On 4/27/21 12:55 AM, olcott wrote:
>>> Message-ID: <Teudndbu59GVBBr9...@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
>>>
>>> Above decision was from the call the Halts inside H_Hat, deciding that
>>> H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
>>> processed below:
>>>
>>>> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
>>>> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
>>>> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
>>>> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
>>>> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
>>>> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
>>>> ...[00000bba][001015d0][00000b98](01) c3 ret
>>>> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
>>>> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
>>>> ...[00000bda][001015d8][00100000](01) 5d pop ebp
>>>> ...[00000bdb][001015dc][00000098](01) c3 ret
>>>
>>> SEE IT HALTED!
>>>
>>>> Number_of_User_Instructions(39)
>>>> Number of Instructions Executed(26567)
>>>
>> The input simulated H(P,P) never halts.
>
> We know what you mean by that: that Ha(Pa,Pa) is reporting on the halt status of the non-input Pn(Pn):
*THIS IS SIMPLY OVER YOUR HEAD*
It is an axiom that when-so-ever any simulating halt decider (SHD)
performs a correct simulation of its input and this simulation would
never stop running unless this simulation is aborted that this SHD is
correct to reject this input as non-halting.

On 8/17/2022 10:26 PM, Richard Damon wrote:
> On 8/17/22 11:17 PM, olcott wrote:
>> On 8/17/2022 10:01 PM, Richard Damon wrote:
>>> On 8/17/22 10:47 PM, olcott wrote:
>>>> On 8/17/2022 9:32 PM, Richard Damon wrote:
>>>>> On 8/17/22 10:14 PM, olcott wrote:
>>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>>>> On 8/17/22 9:12 PM, olcott wrote:
>>>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
>>>>>>>>>>>>>> TM at some
>>>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is
>>>>>>>>>>>>>> correct software
>>>>>>>>>>>>>> engineering.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am biding my time here while I am preparing the code for
>>>>>>>>>>>>>> a much wider
>>>>>>>>>>>>>> audience.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>>>>>
>>>>>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>>>>>> equivalent as I could. H always returns the same value for
>>>>>>>>>>>> the same arguments every time that it is invoked.
>>>>>>>>>>>
>>>>>>>>>>> And this is a key part of your error.
>>>>>>>>>>
>>>>>>>>>> H(P,P) does correctly determine that its input never halts
>>>>>>>>>> there is no error in this.
>>>>>>>>>
>>>>>>>>> Nope, you have shown that it halts.
>>>>>>>> I have shown that the input simulated by H(P,P) reaches the
>>>>>>>> "return" instruction (final state of this input?
>>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> You have shown that the CORRECT (and complete) simulation of the
>>>>>>> input to H(P,P) will Halt.
>>>>>>>
>>>>>> I have shown that the CORRECT (and complete) simulation of the input
>>>>>> to H(P,P) *BY H* will Halt
>>>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>>>>>> (final state)
>>>>>>
>>>>> Except that the only H that actually does this BY DEFINITION
>>>>> doesn't abort its simulaiton and thus doesn't answer.
>>>>>
>>>>
>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>  > You have shown that the CORRECT (and complete) simulation of the
>>>> input
>>>>  > to H(P,P) will Halt.
>>>>
>>>> I have never shown anything like this.
>>>>
>>>>
>>>
>>> Then what is this, but a trace of x86UTM simulating the input that
>>> you give to H(P,P) just in this case you called P H_Hat.
>>>
>>> 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
>>>
>>> Above decision was from the call the Halts inside H_Hat, deciding
>>> that H_Hat(H_Hat) seems to be non-halting, it then returns that
>>> answer and is processed below:
>>>
>>>  > ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
>>>  > ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
>>>  > ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword
>>> [ebp-04],+00
>>>  > ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
>>>  > ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
>>>  > ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
>>>  > ...[00000bba][001015d0][00000b98](01)  c3         ret
>>>  > ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
>>>  > ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
>>>  > ...[00000bda][001015d8][00100000](01)  5d         pop ebp
>>>  > ...[00000bdb][001015dc][00000098](01)  c3         ret
>>>
>>> SEE IT HALTED!
>>>
>>>  > Number_of_User_Instructions(39)
>>>  > Number of Instructions Executed(26567)
>>>
>>
>> The input simulated H(P,P) never halts.
>>
>
> Grammer?
>
> Do you mean BY H, that has been proved to be a meaningless statement,

On Wednesday, August 17, 2022 at 11:43:28 PM UTC-4, olcott wrote:
> On 8/17/2022 10:24 PM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 11:17:16 PM UTC-4, olcott wrote:
> >> On 8/17/2022 10:01 PM, Richard Damon wrote:
> >>> On 8/17/22 10:47 PM, olcott wrote:
> >>>> On 8/17/2022 9:32 PM, Richard Damon wrote:
> >>>>> On 8/17/22 10:14 PM, olcott wrote:
> >>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
> >>>>>>> On 8/17/22 9:12 PM, olcott wrote:
> >>>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
> >>>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
> >>>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
> >>>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So you are saying that the correct and complete x86
> >>>>>>>>>>>>>>>> emulation by H(P,P)
> >>>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
> >>>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
> >>>>>>>>>>>>>> TM at some
> >>>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
> >>>>>>>>>>>>>> software
> >>>>>>>>>>>>>> engineering.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I am biding my time here while I am preparing the code for a
> >>>>>>>>>>>>>> much wider
> >>>>>>>>>>>>>> audience.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
> >>>>>>>>>>>>
> >>>>>>>>>>>> H is a C function, not a program and I made it as Turing
> >>>>>>>>>>>> equivalent as I could. H always returns the same value for the
> >>>>>>>>>>>> same arguments every time that it is invoked.
> >>>>>>>>>>>
> >>>>>>>>>>> And this is a key part of your error.
> >>>>>>>>>>
> >>>>>>>>>> H(P,P) does correctly determine that its input never halts there
> >>>>>>>>>> is no error in this.
> >>>>>>>>>
> >>>>>>>>> Nope, you have shown that it halts.
> >>>>>>>> I have shown that the input simulated by H(P,P) reaches the
> >>>>>>>> "return" instruction (final state of this input?
> >>>>>>>>
> >>>>>>>> computation that halts … the Turing machine will halt whenever it
> >>>>>>>> enters a final state. (Linz:1990:234)
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>
> >>>>>>> You have shown that the CORRECT (and complete) simulation of the
> >>>>>>> input to H(P,P) will Halt.
> >>>>>>>
> >>>>>> I have shown that the CORRECT (and complete) simulation of the input
> >>>>>> to H(P,P) *BY H* will Halt
> >>>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
> >>>>>> (final state)
> >>>>>>
> >>>>> Except that the only H that actually does this BY DEFINITION doesn't
> >>>>> abort its simulaiton and thus doesn't answer.
> >>>>>
> >>>>
> >>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
> >>>> > You have shown that the CORRECT (and complete) simulation of the input
> >>>> > to H(P,P) will Halt.
> >>>>
> >>>> I have never shown anything like this.
> >>>>
> >>>>
> >>>
> >>> Then what is this, but a trace of x86UTM simulating the input that you
> >>> give to H(P,P) just in this case you called P H_Hat.
> >>>
> >>> On 4/27/21 12:55 AM, olcott wrote:
> >>> Message-ID: <Teudndbu59GVBBr9...@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
> >>>
> >>> Above decision was from the call the Halts inside H_Hat, deciding that
> >>> H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
> >>> processed below:
> >>>
> >>>> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> >>>> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> >>>> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> >>>> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> >>>> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> >>>> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> >>>> ...[00000bba][001015d0][00000b98](01) c3 ret
> >>>> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> >>>> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> >>>> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> >>>> ...[00000bdb][001015dc][00000098](01) c3 ret
> >>>
> >>> SEE IT HALTED!
> >>>
> >>>> Number_of_User_Instructions(39)
> >>>> Number of Instructions Executed(26567)
> >>>
> >> The input simulated H(P,P) never halts.
> >
> > We know what you mean by that: that Ha(Pa,Pa) is reporting on the halt status of the non-input Pn(Pn):
> *THIS IS SIMPLY OVER YOUR HEAD*
> It is an axiom

On 8/17/2022 11:19 PM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 11:43:28 PM UTC-4, olcott wrote:
>> On 8/17/2022 10:24 PM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 11:17:16 PM UTC-4, olcott wrote:
>>>> On 8/17/2022 10:01 PM, Richard Damon wrote:
>>>>> On 8/17/22 10:47 PM, olcott wrote:
>>>>>> On 8/17/2022 9:32 PM, Richard Damon wrote:
>>>>>>> On 8/17/22 10:14 PM, olcott wrote:
>>>>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>>>>>> On 8/17/22 9:12 PM, olcott wrote:
>>>>>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
>>>>>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
>>>>>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86
>>>>>>>>>>>>>>>>>> emulation by H(P,P)
>>>>>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>>>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy for
>>>>>>>>>>>>>>>> TM at some
>>>>>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is correct
>>>>>>>>>>>>>>>> software
>>>>>>>>>>>>>>>> engineering.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am biding my time here while I am preparing the code for a
>>>>>>>>>>>>>>>> much wider
>>>>>>>>>>>>>>>> audience.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H the C program is assumed equivalent to H the Turing Machine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H is a C function, not a program and I made it as Turing
>>>>>>>>>>>>>> equivalent as I could. H always returns the same value for the
>>>>>>>>>>>>>> same arguments every time that it is invoked.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And this is a key part of your error.
>>>>>>>>>>>>
>>>>>>>>>>>> H(P,P) does correctly determine that its input never halts there
>>>>>>>>>>>> is no error in this.
>>>>>>>>>>>
>>>>>>>>>>> Nope, you have shown that it halts.
>>>>>>>>>> I have shown that the input simulated by H(P,P) reaches the
>>>>>>>>>> "return" instruction (final state of this input?
>>>>>>>>>>
>>>>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You have shown that the CORRECT (and complete) simulation of the
>>>>>>>>> input to H(P,P) will Halt.
>>>>>>>>>
>>>>>>>> I have shown that the CORRECT (and complete) simulation of the input
>>>>>>>> to H(P,P) *BY H* will Halt
>>>>>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
>>>>>>>> (final state)
>>>>>>>>
>>>>>>> Except that the only H that actually does this BY DEFINITION doesn't
>>>>>>> abort its simulaiton and thus doesn't answer.
>>>>>>>
>>>>>>
>>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
>>>>>>> You have shown that the CORRECT (and complete) simulation of the input
>>>>>>> to H(P,P) will Halt.
>>>>>>
>>>>>> I have never shown anything like this.
>>>>>>
>>>>>>
>>>>>
>>>>> Then what is this, but a trace of x86UTM simulating the input that you
>>>>> give to H(P,P) just in this case you called P H_Hat.
>>>>>
>>>>> On 4/27/21 12:55 AM, olcott wrote:
>>>>> Message-ID: <Teudndbu59GVBBr9...@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
>>>>>
>>>>> Above decision was from the call the Halts inside H_Hat, deciding that
>>>>> H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
>>>>> processed below:
>>>>>
>>>>>> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
>>>>>> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
>>>>>> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
>>>>>> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
>>>>>> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
>>>>>> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
>>>>>> ...[00000bba][001015d0][00000b98](01) c3 ret
>>>>>> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
>>>>>> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
>>>>>> ...[00000bda][001015d8][00100000](01) 5d pop ebp
>>>>>> ...[00000bdb][001015dc][00000098](01) c3 ret
>>>>>
>>>>> SEE IT HALTED!
>>>>>
>>>>>> Number_of_User_Instructions(39)
>>>>>> Number of Instructions Executed(26567)
>>>>>
>>>> The input simulated H(P,P) never halts.
>>>
>>> We know what you mean by that: that Ha(Pa,Pa) is reporting on the halt status of the non-input Pn(Pn):
>> *THIS IS SIMPLY OVER YOUR HEAD*
>> It is an axiom
>
> No it's not because you made it up and no one agrees with it except for you.
>
>> that when-so-ever any simulating halt decider (SHD)
>> performs a correct simulation of its input and this simulation would
>> never stop running unless this simulation is aborted that this SHD is
>> correct to reject this input as non-halting.
>
> In other words, Ha(Pa,Pa) is reporting the halt status of the non-input Pn(Pn) instead of Pa(Pa) like it's required to:

On 2022-08-17 14:08:50 +0000, olcott said:

> On 8/17/2022 4:15 AM, Mikko wrote:
>> On 2022-08-17 01:23:59 +0000, olcott said:
>>
>>> *Not at all. No one has disproved this statement*
>>> H(P,P) does correctly predict that its correct and complete x86
>>> emulation of its input would never stop running, thus does correctly
>>> reject this input as non-halting.
>>
>> This is not really a prediction >
>
> Yes it is really a prediction, otherwise H(P,P) would be required to
> simulate its input forever.
>
>> as it is about a sitation that will
>> never happen.

A dictionary says that "a prediction" is 'a statement of what will happen
in future'. Your statement has "would" instead of "will" so it is not a
prediction.

Mikko

On 8/17/22 11:43 PM, olcott wrote:
> *THIS IS SIMPLY OVER YOUR HEAD*
> It is an axiom that when-so-ever any simulating halt decider (SHD)
> performs a correct simulation of its input and this simulation would
> never stop running unless this simulation is aborted that this SHD is
> correct to reject this input as non-halting.
>

LIE.

You have yet to document this claimed axiom, so it is just a FALSE
STATEMENT. You CAN'T document, because it isn't actually true.
Apparently, you don't understand the actual meaning of an Axiom.

It is CLOSE to a correct statement, but close only counts in Horse shoes
and Hand grenades. (Maybe you should take up Hand Granade Juggling).

Since you proof is based on a false statement, it is unsound, just as
you have proved yourself to be.

PERIOD.

On 8/18/22 12:32 AM, olcott wrote:

>> In other words, Ha(Pa,Pa) is reporting the halt status of the
>> non-input Pn(Pn) instead of Pa(Pa) like it's required to:
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> Every simulating halt decider always predicts what the behavior of its
> input would be if it performed a correct and complete simulation of this
> input.
>
>
>

Fallacy of Proof by Example, and the Red Herring.

Also, Not the definition of a Halt Decide, so you are just serving your
POOP.

On 8/17/22 11:52 PM, olcott wrote:
> On 8/17/2022 10:26 PM, Richard Damon wrote:
>> On 8/17/22 11:17 PM, olcott wrote:

>>> The input simulated H(P,P) never halts.
>>>
>>
>> Grammer?
>>
>> Do you mean BY H, that has been proved to be a meaningless statement,
>
>

So, the following reply doesn't answer the statement it appears to be
replying to.

The one who will not read is no better than the one who can not read.

Thus, you are showing yourself to be functionally illiterate.

>
> *H0 correctly determines that its correct and complete*
> *simulation of Infinite_Loop would never halt*
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
>
> *H correctly determines that its correct and complete*
> *simulation of Infinite_Recursion would never halt*
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }
>
>
> *H correctly determines that its correct and complete*
> *simulation of P would never halt*
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ",  H(P, P));
> }
>

Fallacy of Proof by Example, shows you failed basic logic.

By that method I can prove that All Catas are black.

After all, that statement is true for my two cats Blackie and Midnight.

The fact that H gets a couple of trivial examples correct, doesn't mean
that it is using the right method for something more complicated.

On 8/18/2022 6:46 AM, Richard Damon wrote:
> On 8/17/22 11:52 PM, olcott wrote:
>> On 8/17/2022 10:26 PM, Richard Damon wrote:
>>> On 8/17/22 11:17 PM, olcott wrote:
>
>>>> The input simulated H(P,P) never halts.
>>>>
>>>
>>> Grammer?
>>>
>>> Do you mean BY H, that has been proved to be a meaningless statement,
>>
>>
>
> So, the following reply doesn't answer the statement it appears to be
> replying to.
>
> The one who will not read is no better than the one who can not read.
>
> Thus, you are showing yourself to be functionally illiterate.
>
>>
>> *H0 correctly determines that its correct and complete*
>> *simulation of Infinite_Loop would never halt*
>>
>> void Infinite_Loop()
>> {
>>    HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>> }
>>
>>
>> *H correctly determines that its correct and complete*
>> *simulation of Infinite_Recursion would never halt*
>>
>> void Infinite_Recursion(int N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>> }
>>
>>
>> *H correctly determines that its correct and complete*
>> *simulation of P would never halt*
>>
>> void P(ptr x)
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ",  H(P, P));
>> }
>>
>
> Fallacy of Proof by Example, shows you failed basic logic.

*Proofs of existential statements*
In some scenarios, an argument by example may be valid if it leads from
a singular premise to an existential conclusion (i.e. proving that a
claim is true for at least one case, instead of for all cases). For
example: Socrates is wise. Therefore, someone is wise.
https://en.wikipedia.org/wiki/Proof_by_example

If I prove that I can lift a specific bucket of water by lifting this
bucket of water this is not the over-generalization of the proof by
example.

The statement that no H exists that correctly determines the halt status
of P is refuted by a single example H that correctly determines the halt
status of P.

--
Copyright 2022 Pete Olcott

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

On Thu, 18 Aug 2022 09:10:57 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/18/2022 3:23 AM, Mikko wrote:
> > On 2022-08-17 14:08:50 +0000, olcott said:
> >
> >> On 8/17/2022 4:15 AM, Mikko wrote:
> >>> On 2022-08-17 01:23:59 +0000, olcott said:
> >>>
> >>>> *Not at all. No one has disproved this statement*
> >>>> H(P,P) does correctly predict that its correct and complete x86
> >>>> emulation of its input would never stop running, thus does
> >>>> correctly reject this input as non-halting.
> >>>
> >>> This is not really a prediction >
> >>
> >> Yes it is really a prediction, otherwise H(P,P) would be required
> >> to simulate its input forever.
> >>
> >>> as it is about a sitation that will
> >>> never happen.
> >
> > A dictionary says that "a prediction" is 'a statement of what will
> > happen in future'. Your statement has "would" instead of "will" so
> > it is not a prediction.
> >
> > Mikko
> >
>
> If you just want to play silly word games then please STFU!!! I am
> trying to validate my legacy and everyone here only wants to troll me.
>
> It is an axiom that when-so-ever any simulating halt decider (SHD)
> performs a correct simulation of its input and this simulation would
> never stop running unless this simulation is aborted that this SHD is
> correct to reject this input as non-halting.

Not if P would have halted *if* H returned to P rather than aborting
the simulation. My solution is the only credible solution, yours isn't
because it simply doesn't work.

/Flibble

On Wed, 17 Aug 2022 22:43:20 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 10:24 PM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 11:17:16 PM UTC-4, olcott wrote:
> >> On 8/17/2022 10:01 PM, Richard Damon wrote:
> >>> On 8/17/22 10:47 PM, olcott wrote:
> >>>> On 8/17/2022 9:32 PM, Richard Damon wrote:
> >>>>> On 8/17/22 10:14 PM, olcott wrote:
> >>>>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
> >>>>>>> On 8/17/22 9:12 PM, olcott wrote:
> >>>>>>>> On 8/17/2022 7:49 PM, Richard Damon wrote:
> >>>>>>>>> On 8/17/22 11:08 AM, olcott wrote:
> >>>>>>>>>> On 8/17/2022 6:51 AM, Richard Damon wrote:
> >>>>>>>>>>> On 8/17/22 1:57 AM, olcott wrote:
> >>>>>>>>>>>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott
> >>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So you are saying that the correct and complete x86
> >>>>>>>>>>>>>>>> emulation by H(P,P)
> >>>>>>>>>>>>>>>> of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H is , by definition, a Turing Machine and therefore
> >>>>>>>>>>>>>>> halts.
> >>>>>>>>>>>>>> H is a C function that I hope to show is a valid proxy
> >>>>>>>>>>>>>> for TM at some
> >>>>>>>>>>>>>> future date, after it is accepted that H(P,P)==0 is
> >>>>>>>>>>>>>> correct software
> >>>>>>>>>>>>>> engineering.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I am biding my time here while I am preparing the code
> >>>>>>>>>>>>>> for a much wider
> >>>>>>>>>>>>>> audience.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> H the C program is assumed equivalent to H the Turing
> >>>>>>>>>>>>> Machine.
> >>>>>>>>>>>>
> >>>>>>>>>>>> H is a C function, not a program and I made it as Turing
> >>>>>>>>>>>> equivalent as I could. H always returns the same value
> >>>>>>>>>>>> for the same arguments every time that it is invoked.
> >>>>>>>>>>>
> >>>>>>>>>>> And this is a key part of your error.
> >>>>>>>>>>
> >>>>>>>>>> H(P,P) does correctly determine that its input never halts
> >>>>>>>>>> there is no error in this.
> >>>>>>>>>
> >>>>>>>>> Nope, you have shown that it halts.
> >>>>>>>> I have shown that the input simulated by H(P,P) reaches the
> >>>>>>>> "return" instruction (final state of this input?
> >>>>>>>>
> >>>>>>>> computation that halts … the Turing machine will halt
> >>>>>>>> whenever it enters a final state. (Linz:1990:234)
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>
> >>>>>>> You have shown that the CORRECT (and complete) simulation of
> >>>>>>> the input to H(P,P) will Halt.
> >>>>>>>
> >>>>>> I have shown that the CORRECT (and complete) simulation of the
> >>>>>> input to H(P,P) *BY H* will Halt
> >>>>>> *MEANING THE THE SIMULATED INPUT REACHES ITS "return"
> >>>>>> instruction* (final state)
> >>>>>>
> >>>>> Except that the only H that actually does this BY DEFINITION
> >>>>> doesn't abort its simulaiton and thus doesn't answer.
> >>>>>
> >>>>
> >>>> On 8/17/2022 8:36 PM, Richard Damon wrote:
> >>>> > You have shown that the CORRECT (and complete) simulation of
> >>>> > the input to H(P,P) will Halt.
> >>>>
> >>>> I have never shown anything like this.
> >>>>
> >>>>
> >>>
> >>> Then what is this, but a trace of x86UTM simulating the input
> >>> that you give to H(P,P) just in this case you called P H_Hat.
> >>>
> >>> On 4/27/21 12:55 AM, olcott wrote:
> >>> Message-ID: <Teudndbu59GVBBr9...@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
> >>>
> >>> Above decision was from the call the Halts inside H_Hat, deciding
> >>> that H_Hat(H_Hat) seems to be non-halting, it then returns that
> >>> answer and is processed below:
> >>>
> >>>> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> >>>> ...[00000bac][001015c4][00000000](03) 8945fc mov
> >>>> [ebp-04],eax ...[00000baf][001015c4][00000000](04) 837dfc00
> >>>> cmp dword [ebp-04],+00 ...[00000bb3][001015c4][00000000](02)
> >>>> 7402 jz 00000bb7 ...[00000bb7][001015c8][001015d4](02)
> >>>> 8be5 mov esp,ebp ...[00000bb9][001015cc][00000bd5](01) 5d
> >>>> pop ebp ...[00000bba][001015d0][00000b98](01) c3
> >>>> ret ...[00000bd5][001015d4][00000000](03) 83c404 add
> >>>> esp,+04 ...[00000bd8][001015d4][00000000](02) 33c0 xor
> >>>> eax,eax ...[00000bda][001015d8][00100000](01) 5d pop ebp
> >>>> ...[00000bdb][001015dc][00000098](01) c3 ret
> >>>
> >>> SEE IT HALTED!
> >>>
> >>>> Number_of_User_Instructions(39)
> >>>> Number of Instructions Executed(26567)
> >>>
> >> The input simulated H(P,P) never halts.
> >
> > We know what you mean by that: that Ha(Pa,Pa) is reporting on the
> > halt status of the non-input Pn(Pn):
> *THIS IS SIMPLY OVER YOUR HEAD*
> It is an axiom that when-so-ever any simulating halt decider (SHD)
> performs a correct simulation of its input and this simulation would
> never stop running unless this simulation is aborted that this SHD is
> correct to reject this input as non-halting.

On Wed, 17 Aug 2022 18:14:48 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 5:28 PM, Ben Bacarisse wrote:
> > "dklei...@gmail.com" <dkleinecke@gmail.com> writes:
> >
> >> On Wednesday, August 17, 2022 at 1:59:32 PM UTC-7, olcott wrote:
> >>> On 8/17/2022 3:42 PM, dklei...@gmail.com wrote:
> >>>> On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, Ben Bacarisse
> >>>> wrote:
> >>>>> "dklei...@gmail.com" <dklei...@gmail.com> writes:
> >>>>>
> >>>>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
> >>>>>>
> >>>>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
> >>>>
> >>>>>>>> H is , by definition, a Turing Machine and therefore halts.
> >>>>>
> >>>>> Did you mean to say that? Perhaps you meant to say that H is, by
> >>>>> definition, a decider and a decider halts regardless of the
> >>>>> initial tape?
> >>>>>
> >>>> I goofed up. I meant that H always returns a value and therefore
> >>>> always halts. That it is a Turing Machine is implicit.
> >>> I specify that H is a C function, when you say it is a TM that is
> >>> the same as saying that cats are dogs.
> >>>
> >>> Whether or not this C function is equivalent to a TM is a whole
> >>> different conversation, I am (at this point) only saying that
> >>> H(P,P) does correctly determine that its first argument specifies
> >>> a sequence of instructions that never halt.
> >>>
> >>> ONLY after mutual understanding is achieved on this point can we
> >>> move on to the different subject of whether or not H is
> >>> equivalent to a TM.
> >> We are concerned with a classical procedure - a halting decider. A
> >> halting decider is a halting Turing Machine that, given an
> >> encoding of some Turing Machine on its initial tape returns a
> >> "true" if the encoded machine, when run, will halt and a "false"
> >> otherwise.
> >>
> >> The only reason for interest in any C program is that we are going
> >> to assume the the C program is equivalent to the halting decider.
> >> One of the problems with this discussion has been too many things
> >> are all called H.
> >>
> >> Incidentally it seem to be a theorem that for any N there are two
> >> different Turing Machines one of which halts and the other does
> >> not where the first N steps when run are identical. This, in a way,
> >> destroys the idea of a simulating halt decider.
> >
> > Well, yes (trivially so). But then there is a theorem that states
> > that there are no halt deciders, simulating or otherwise, and
> > /that/ theorem has not had any impact on POs in the last 18 years.
> >
> > The trouble is that theorems run off PO like water off a duck's
> > back. He thinks of them like arguments made in court, and he see
> > himself as a mathematical Perry Mason presenting a dramatic "Aha!"
> > moment. I once asked him if there was any theorem of which he was
> > so sure that he could not imagine any sane person rejecting it, and
> > he just kept ducking the question.
> >
> > Anyway, good luck. Maybe this remark will be the one that, after 18
> > years, makes PO slap his forehead go "gosh, you're right; what /was/
> > I thinking!".
> >
>
> The problem seems to be that you lack the technical competence to
> review my work in that after I published the source-code you still
> thought it was a ruse until Mike corrected you and told you that my
> code does behave as I have claimed.

If the code does as you have claimed then the code is worthless as your
halting decider isn't a halting decider because it doesn't actually
determine the halting status of an input that reference your halting
decider.

/Flibble

On 8/18/2022 11:06 AM, Mr Flibble wrote:
> On Thu, 18 Aug 2022 09:10:57 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/18/2022 3:23 AM, Mikko wrote:
>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>
>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>
>>>>>> *Not at all. No one has disproved this statement*
>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>> emulation of its input would never stop running, thus does
>>>>>> correctly reject this input as non-halting.
>>>>>
>>>>> This is not really a prediction >
>>>>
>>>> Yes it is really a prediction, otherwise H(P,P) would be required
>>>> to simulate its input forever.
>>>>
>>>>> as it is about a sitation that will
>>>>> never happen.
>>>
>>> A dictionary says that "a prediction" is 'a statement of what will
>>> happen in future'. Your statement has "would" instead of "will" so
>>> it is not a prediction.
>>>
>>> Mikko
>>>
>>
>> If you just want to play silly word games then please STFU!!! I am
>> trying to validate my legacy and everyone here only wants to troll me.
>>
>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>> performs a correct simulation of its input and this simulation would
>> never stop running unless this simulation is aborted that this SHD is
>> correct to reject this input as non-halting.
>
> Not if P would have halted *if* H returned to P rather than aborting
> the simulation. My solution is the only credible solution, yours isn't
> because it simply doesn't work.
>
> /Flibble
>

This is what I mean when I say that you are incompetent at software
engineering. There is no possible way that simulating halt decider H can
correctly return to P. You apparently are totally clueless about basic
software engineering:

No function called in (what is essentially) infinite recursion can
possibly correctly return to its caller.

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

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

--
Copyright 2022 Pete Olcott

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

On 2022-08-18 14:10:57 +0000, olcott said:

> If you just want to play silly word games then please STFU!!! I am
> trying to validate my legacy and everyone here only wants to troll me.

You are the one how calls a non-prediction a "prediction", a
non-halt-decider a "halt decider", and a non-axion an "axiom".
Pointing those out is not a word game.

> It is an axiom that when-so-ever any simulating halt decider (SHD)
> performs a correct simulation of its input and this simulation would
> never stop running unless this simulation is aborted that this SHD is
> correct to reject this input as non-halting.

Nothing containing the word "would" is an axiom.

Mikko

On Thu, 18 Aug 2022 11:20:49 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/18/2022 11:06 AM, Mr Flibble wrote:
> > On Thu, 18 Aug 2022 09:10:57 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/18/2022 3:23 AM, Mikko wrote:
> >>> On 2022-08-17 14:08:50 +0000, olcott said:
> >>>
> >>>> On 8/17/2022 4:15 AM, Mikko wrote:
> >>>>> On 2022-08-17 01:23:59 +0000, olcott said:
> >>>>>
> >>>>>> *Not at all. No one has disproved this statement*
> >>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>> emulation of its input would never stop running, thus does
> >>>>>> correctly reject this input as non-halting.
> >>>>>
> >>>>> This is not really a prediction >
> >>>>
> >>>> Yes it is really a prediction, otherwise H(P,P) would be required
> >>>> to simulate its input forever.
> >>>>
> >>>>> as it is about a sitation that will
> >>>>> never happen.
> >>>
> >>> A dictionary says that "a prediction" is 'a statement of what will
> >>> happen in future'. Your statement has "would" instead of "will" so
> >>> it is not a prediction.
> >>>
> >>> Mikko
> >>>
> >>
> >> If you just want to play silly word games then please STFU!!! I am
> >> trying to validate my legacy and everyone here only wants to troll
> >> me.
> >>
> >> It is an axiom that when-so-ever any simulating halt decider (SHD)
> >> performs a correct simulation of its input and this simulation
> >> would never stop running unless this simulation is aborted that
> >> this SHD is correct to reject this input as non-halting.
> >
> > Not if P would have halted *if* H returned to P rather than aborting
> > the simulation. My solution is the only credible solution, yours
> > isn't because it simply doesn't work.
> >
> > /Flibble
> >
>
> This is what I mean when I say that you are incompetent at software
> engineering. There is no possible way that simulating halt decider H
> can correctly return to P. You apparently are totally clueless about
> basic software engineering:

You apparently are as obtuse as fuck and a pathological liar. Again: I
have designed a simulating halt decider that does correctly return to P.

>
> No function called in (what is essentially) infinite recursion can
> possibly correctly return to its caller.

My SHD doesn't manifest any infinite recursion because it works, your
does manifest it because yours doesn't work.

>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }

void Px(ptr x)
{ (void)H(x, x);
return;
}

Your H decides that Px doesn't halt when it is plain to see that Px
does halt.

/Flibble

On 8/18/2022 11:26 AM, Mikko wrote:
> On 2022-08-18 14:10:57 +0000, olcott said:
>
>> If you just want to play silly word games then please STFU!!! I am
>> trying to validate my legacy and everyone here only wants to troll me.
>
> You are the one how calls a non-prediction a "prediction", a
> non-halt-decider a "halt decider", and a non-axion an "axiom".
> Pointing those out is not a word game.
>
>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>> performs a correct simulation of its input and this simulation would
>> never stop running unless this simulation is aborted that this SHD is
>> correct to reject this input as non-halting.
>
> Nothing containing the word "would" is an axiom.
>
> Mikko
>

If premise is true then the conclusion is derived.

If H0(Infinite_Loop) correctly determines that its pure simulation of
its input would never stop running then H0 can correctly reject this
input as non-halting.

void Infinite_Loop()
{ HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H0((u32)Infinite_Loop));
}

_Infinite_Loop()
[00001102](01) 55 push ebp
[00001103](02) 8bec mov ebp,esp
[00001105](02) ebfe jmp 00001105
[00001107](01) 5d pop ebp
[00001108](01) c3 ret
Size in bytes:(0007) [00001108]

--
Copyright 2022 Pete Olcott

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

On 8/18/2022 11:30 AM, Mr Flibble wrote:
> On Thu, 18 Aug 2022 11:20:49 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
>>> On Thu, 18 Aug 2022 09:10:57 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/18/2022 3:23 AM, Mikko wrote:
>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>>>
>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>>>
>>>>>>>> *Not at all. No one has disproved this statement*
>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>> emulation of its input would never stop running, thus does
>>>>>>>> correctly reject this input as non-halting.
>>>>>>>
>>>>>>> This is not really a prediction >
>>>>>>
>>>>>> Yes it is really a prediction, otherwise H(P,P) would be required
>>>>>> to simulate its input forever.
>>>>>>
>>>>>>> as it is about a sitation that will
>>>>>>> never happen.
>>>>>
>>>>> A dictionary says that "a prediction" is 'a statement of what will
>>>>> happen in future'. Your statement has "would" instead of "will" so
>>>>> it is not a prediction.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> If you just want to play silly word games then please STFU!!! I am
>>>> trying to validate my legacy and everyone here only wants to troll
>>>> me.
>>>>
>>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>>> performs a correct simulation of its input and this simulation
>>>> would never stop running unless this simulation is aborted that
>>>> this SHD is correct to reject this input as non-halting.
>>>
>>> Not if P would have halted *if* H returned to P rather than aborting
>>> the simulation. My solution is the only credible solution, yours
>>> isn't because it simply doesn't work.
>>>
>>> /Flibble
>>>
>>
>> This is what I mean when I say that you are incompetent at software
>> engineering. There is no possible way that simulating halt decider H
>> can correctly return to P. You apparently are totally clueless about
>> basic software engineering:
>
> You apparently are as obtuse as fuck and a pathological liar. Again: I
> have designed a simulating halt decider that does correctly return to P.
>
>>
>> No function called in (what is essentially) infinite recursion can
>> possibly correctly return to its caller.
>
> My SHD doesn't manifest any infinite recursion because it works, your
> does manifest it because yours doesn't work.

You can't even specify the condition that invokes the behavior of your
code: {if something magical happens} then return to caller.
Post your link again so that everyone can see.

--
Copyright 2022 Pete Olcott

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

On Thu, 18 Aug 2022 11:50:36 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/18/2022 11:30 AM, Mr Flibble wrote:
> > On Thu, 18 Aug 2022 11:20:49 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/18/2022 11:06 AM, Mr Flibble wrote:
> >>> On Thu, 18 Aug 2022 09:10:57 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/18/2022 3:23 AM, Mikko wrote:
> >>>>> On 2022-08-17 14:08:50 +0000, olcott said:
> >>>>>
> >>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
> >>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
> >>>>>>>
> >>>>>>>> *Not at all. No one has disproved this statement*
> >>>>>>>> H(P,P) does correctly predict that its correct and complete
> >>>>>>>> x86 emulation of its input would never stop running, thus
> >>>>>>>> does correctly reject this input as non-halting.
> >>>>>>>
> >>>>>>> This is not really a prediction >
> >>>>>>
> >>>>>> Yes it is really a prediction, otherwise H(P,P) would be
> >>>>>> required to simulate its input forever.
> >>>>>>
> >>>>>>> as it is about a sitation that will
> >>>>>>> never happen.
> >>>>>
> >>>>> A dictionary says that "a prediction" is 'a statement of what
> >>>>> will happen in future'. Your statement has "would" instead of
> >>>>> "will" so it is not a prediction.
> >>>>>
> >>>>> Mikko
> >>>>>
> >>>>
> >>>> If you just want to play silly word games then please STFU!!! I
> >>>> am trying to validate my legacy and everyone here only wants to
> >>>> troll me.
> >>>>
> >>>> It is an axiom that when-so-ever any simulating halt decider
> >>>> (SHD) performs a correct simulation of its input and this
> >>>> simulation would never stop running unless this simulation is
> >>>> aborted that this SHD is correct to reject this input as
> >>>> non-halting.
> >>>
> >>> Not if P would have halted *if* H returned to P rather than
> >>> aborting the simulation. My solution is the only credible
> >>> solution, yours isn't because it simply doesn't work.
> >>>
> >>> /Flibble
> >>>
> >>
> >> This is what I mean when I say that you are incompetent at software
> >> engineering. There is no possible way that simulating halt decider
> >> H can correctly return to P. You apparently are totally clueless
> >> about basic software engineering:
> >
> > You apparently are as obtuse as fuck and a pathological liar.
> > Again: I have designed a simulating halt decider that does
> > correctly return to P.
> >>
> >> No function called in (what is essentially) infinite recursion can
> >> possibly correctly return to its caller.
> >
> > My SHD doesn't manifest any infinite recursion because it works,
> > your does manifest it because yours doesn't work.
>
> You can't even specify the condition that invokes the behavior of
> your code: {if something magical happens} then return to caller.
> Post your link again so that everyone can see.

If H is called with the same inputs a second time then it returns *both*
halting and non-halting decisions to the caller in a forked simulation.

/Flibble