On 6/27/2022 1:13 PM, Dennis Bush wrote:
> On Monday, June 27, 2022 at 2:11:45 PM UTC-4, olcott wrote:
>> On 6/27/2022 1:03 PM, Dennis Bush wrote:
>>> On Monday, June 27, 2022 at 1:20:39 PM UTC-4, olcott wrote:
>>>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
>>>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
>>>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
>>>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
>>>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
>>>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
>>>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> *This is the outline of the complete refutation*
>>>>>>>>>>>>>> *of the only rebuttal that anyone has left*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>> never reaches the "ret" instruction of P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
>>>>>>>>>>>>>> the semantics of the x86 language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
>>>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H does not perform this mapping.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>> [000011f0](01) 55 push ebp
>>>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000011f6](01) 50 push eax
>>>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000011fa](01) 51 push ecx
>>>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
>>>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
>>>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
>>>>>>>>>>>>>> [00001209](01) 5d pop ebp
>>>>>>>>>>>>>> [0000120a](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>> [00001210](01) 55 push ebp
>>>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
>>>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
>>>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
>>>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001222](01) 5d pop ebp
>>>>>>>>>>>>>> [00001223](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0020) [00001223]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
>>>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
>>>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
>>>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
>>>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
>>>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
>>>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
>>>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
>>>>>>>>>>>>>> Address_of_H:1020
>>>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
>>>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
>>>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
>>>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
>>>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
>>>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
>>>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
>>>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
>>>>>>>>>>>>>> recursive emulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FALSE. P contains these instructions:
>>>>>>>>>>>>>
>>>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
>>>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
>>>>>>>>>>>>> goto END_OF_CODE;
>>>>>>>>>>>>> return 0; // Does not halt
>>>>>>>>>>>>> END_OF_CODE:
>>>>>>>>>>>>> return 1; // Input has normally terminated
>>>>>>>>>>>>>
>>>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
>>>>>>>>>>>>>
>>>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
>>>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
>>>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
>>>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
>>>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
>>>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
>>>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
>>>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
>>>>>>>>>>>> input never reaches the the "ret" instruction of P.
>>>>>>>>>>>
>>>>>>>>>>> Repeating your original point.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This is the actual behavior of the input to H(P,P).
>>>>>>>>>>>>
>>>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Again, repeating your original point.
>>>>>>>>>>>
>>>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>> Therefore H(P,P)==0 is correct.
>>>>>>>>>>>
>>>>>>>>>>> And again, repeating your original point.
>>>>>>>>>>>
>>>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
>>>>>>>>>>>
>>>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
>>>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
>>>>>>>>>> halt decider correctly predicts that its correctly simulated input will
>>>>>>>>>> never reach the final state "ret" instruction of this input.
>>>>>>>>>
>>>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>> First of all I am not talking about UTM's.
>>>>>>>> I am talking about x86 emulation.
>>>>>>>> Try to encode what you mean, here is my guess:
>>>>>>>>
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>> if (emulate_x86(x, x))
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>> }
>>>>>>>
>>>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
>>>>>>>
>>>>>>> void UTM(u32 x, u32 y)
>>>>>>> {
>>>>>>> x(y)
>>>>>>> }
>>>>>>>
>>>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
>>>>>>>
>>>>>> A simulating halt decider correctly simulates its input until it
>>>>>> correctly determines that this simulated input would never reach its
>>>>>> final state.
>>>>>
>>>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
>>>>>
>>>> Every simulating decider that correctly simulates its input until it
>>>> correctly determines that this simulated input would never reach its
>>>> final state correctly determines the halt status of this input.
>>>
>>> And H isn't such a decider, because it does not correctly determine that the input to H(P,P) would never halt as demonstrated by UTM(P,P) halting.
>>>
>>> The specification for H:
>>>
>>> H(x,y)==0 if and only if x(y) does not halt, and
>>> H(x,y)==1 if and only if x(y) halts.
>>>
>>> H does not meet the specification.
>>>
>> The spec is provably incorrect in this case:
>
> A spec can't be incorrect. It just is. If it can't be satisfied, then that validates the halting problem proofs that say it can't be satisfied.

On 6/27/2022 1:08 PM, Dennis Bush wrote:
> On Monday, June 27, 2022 at 1:59:58 PM UTC-4, olcott wrote:
>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
>>>>>>>>>>>> *This is the outline of the complete refutation*
>>>>>>>>>>>> *of the only rebuttal that anyone has left*
>>>>>>>>>>>>
>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>> never reaches the "ret" instruction of P.
>>>>>>>>>>>
>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>>>>>>>>>>>
>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
>>>>>>>>>>>
>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>>>>>>>>>
>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
>>>>>>>>>>>> the semantics of the x86 language.
>>>>>>>>>>>
>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>
>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
>>>>>>>>>>>
>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
>>>>>>>>>>>
>>>>>>>>>>> H does not perform this mapping.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
>>>>>>>>>>>
>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> P(P);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [000011f0](01) 55 push ebp
>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000011f6](01) 50 push eax
>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000011fa](01) 51 push ecx
>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
>>>>>>>>>>>>
>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
>>>>>>>>>>>> [00001209](01) 5d pop ebp
>>>>>>>>>>>> [0000120a](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [00001210](01) 55 push ebp
>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
>>>>>>>>>>>> [00001222](01) 5d pop ebp
>>>>>>>>>>>> [00001223](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0020) [00001223]
>>>>>>>>>>>>
>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>> address address data code language
>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
>>>>>>>>>>>>
>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
>>>>>>>>>>>> Address_of_H:1020
>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
>>>>>>>>>>>> recursive emulation.
>>>>>>>>>>>
>>>>>>>>>>> FALSE. P contains these instructions:
>>>>>>>>>>>
>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
>>>>>>>>>>> goto END_OF_CODE;
>>>>>>>>>>> return 0; // Does not halt
>>>>>>>>>>> END_OF_CODE:
>>>>>>>>>>> return 1; // Input has normally terminated
>>>>>>>>>>>
>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
>>>>>>>>>>>
>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
>>>>>>>>>>>
>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
>>>>>>>>>>>> executed P
>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
>>>>>>>>>>>> executed P
>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
>>>>>>>>>>>
>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
>>>>>>>>>> input never reaches the the "ret" instruction of P.
>>>>>>>>>
>>>>>>>>> Repeating your original point.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This is the actual behavior of the input to H(P,P).
>>>>>>>>>>
>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Again, repeating your original point.
>>>>>>>>>
>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>> specified by these inputs.
>>>>>>>>>> Therefore H(P,P)==0 is correct.
>>>>>>>>>
>>>>>>>>> And again, repeating your original point.
>>>>>>>>>
>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
>>>>>>>>>
>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
>>>>>>>> halt decider correctly predicts that its correctly simulated input will
>>>>>>>> never reach the final state "ret" instruction of this input.
>>>>>>>
>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>> First of all I am not talking about UTM's.
>>>>>> I am talking about x86 emulation.
>>>>>> Try to encode what you mean, here is my guess:
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> if (emulate_x86(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>> }
>>>>>
>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
>>>>>
>>>>> void UTM(u32 x, u32 y)
>>>>> {
>>>>> x(y)
>>>>> }
>>>>>
>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
>>>>>
>>>> A simulating halt decider correctly simulates its input until it
>>>> correctly determines that this simulated input would never reach its
>>>> final state.
>>>
>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
>>>
>> The semantics of the x86 language conclusively proves that H(P,P)
>> correctly determines/predicts that its complete and correct x86
>> emulation of its input would never reach the "ret" instruction of P.
>
> As previously stated, this is nonsense. Failure to explain *in detail* why the below is wrong will be taken as an admission that it is correct.
>
> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>
> To state that H aborts *and* does a complete and correct simulation is simply nonsense.

On 6/27/2022 1:20 PM, Mr Flibble wrote:
> On Mon, 27 Jun 2022 07:05:46 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> *This is the outline of the complete refutation*
>> *of the only rebuttal that anyone has left*
>>
>> (a) The complete and correct x86 emulation of the input to H(P,P) by
>> H never reaches the "ret" instruction of P.
>>
>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>
>> The above two are proven to be verified facts entirely on the basis
>> of the semantics of the x86 language.
>>
>> A halt decider must compute the mapping from its inputs to an accept
>> or reject state on the basis of the actual behavior that is actually
>> specified by these inputs.
>>
>> P(P) is provably not the actual behavior of the actual input.
>>
>>
>>
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>> }
>>
>> _P()
>> [0000163a](01) 55 push ebp
>> [0000163b](02) 8bec mov ebp,esp
>> [0000163d](03) 8b4508 mov eax,[ebp+08]
>> [00001640](01) 50 push eax
>> [00001641](03) 8b4d08 mov ecx,[ebp+08]
>> [00001644](01) 51 push ecx
>> [00001645](05) e8f0fdffff call 0000143a // call H
>> [0000164a](03) 83c408 add esp,+08
>> [0000164d](02) 85c0 test eax,eax
>> [0000164f](02) 7402 jz 00001653
>> [00001651](02) ebfe jmp 00001651
>> [00001653](01) 5d pop ebp
>> [00001654](01) c3 ret
>> Size in bytes:(0027) [00001654]
>>
>> _main()
>> [0000165a](01) 55 push ebp
>> [0000165b](02) 8bec mov ebp,esp
>> [0000165d](05) 683a160000 push 0000163a // push P
>> [00001662](05) 683a160000 push 0000163a // push P
>> [00001667](05) e8cef9ffff call 0000103a // call H1
>> [0000166c](03) 83c408 add esp,+08
>> [0000166f](01) 50 push eax // push return value
>> [00001670](05) 689b040000 push 0000049b // "Input_Halts = "
>> [00001675](05) e870eeffff call 000004ea // call Output
>> [0000167a](03) 83c408 add esp,+08
>> [0000167d](02) 33c0 xor eax,eax
>> [0000167f](01) 5d pop ebp
>> [00001680](01) c3 ret
>> Size in bytes:(0039) [00001680]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [0000165a][001026a9][00000000] 55 push ebp
>> [0000165b][001026a9][00000000] 8bec mov ebp,esp
>> [0000165d][001026a5][0000163a] 683a160000 push 0000163a // push P
>> [00001662][001026a1][0000163a] 683a160000 push 0000163a // push P
>> [00001667][0010269d][0000166c] e8cef9ffff call 0000103a // call H1
>>
>> H1: Begin Simulation Execution Trace Stored at:21275d
>> Address_of_H1:103a
>> [0000163a][00212749][0021274d] 55 push ebp
>> [0000163b][00212749][0021274d] 8bec mov ebp,esp
>> [0000163d][00212749][0021274d] 8b4508 mov eax,[ebp+08]
>> [00001640][00212745][0000163a] 50 push eax // push P
>> [00001641][00212745][0000163a] 8b4d08 mov ecx,[ebp+08]
>> [00001644][00212741][0000163a] 51 push ecx // push P
>> [00001645][0021273d][0000164a] e8f0fdffff call 0000143a // call H
>>
>> H: Begin Simulation Execution Trace Stored at:2285c5
>> Address_of_H:143a
>> [0000163a][002285b1][002285b5] 55 push ebp
>> [0000163b][002285b1][002285b5] 8bec mov ebp,esp
>> [0000163d][002285b1][002285b5] 8b4508 mov eax,[ebp+08]
>> [00001640][002285ad][0000163a] 50 push eax // push P
>> [00001641][002285ad][0000163a] 8b4d08 mov ecx,[ebp+08]
>> [00001644][002285a9][0000163a] 51 push ecx // push P
>> [00001645][002285a5][0000164a] e8f0fdffff call 0000143a // call H
>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>> [0000164d][00212749][0021274d] 85c0 test eax,eax
>> [0000164f][00212749][0021274d] 7402 jz 00001653
>> [00001653][0021274d][0000111e] 5d pop ebp
>> [00001654][00212751][0000163a] c3 ret
>> H1: End Simulation Input Terminated Normally
>>
>> [0000166c][001026a9][00000000] 83c408 add esp,+08
>> [0000166f][001026a5][00000001] 50 push eax // return
>> value [00001670][001026a1][0000049b] 689b040000 push 0000049b //
>> "Input_Halts = " [00001675][001026a1][0000049b] e870eeffff call
>> 000004ea // call Output Input_Halts = 1
>> [0000167a][001026a9][00000000] 83c408 add esp,+08
>> [0000167d][001026a9][00000000] 33c0 xor eax,eax
>> [0000167f][001026ad][00100000] 5d pop ebp
>> [00001680][001026b1][00000004] c3 ret
>> Number of Instructions Executed(409590) == 6113 Pages
>
> Why the new H/H1 dichotomy? Are you finally admitting that the decider
> that main() calls is different to the decider that P would call if you
> weren't erroneously aborting the simulation?
>
> /Flibble
>

The above example proves the following:

(a) The complete and correct x86 emulation of the input to H(P,P) by H
never reaches the "ret" instruction of P.

(b) The direct execution of P(P) does reach its "ret" instruction.

The above two are proven to be verified facts entirely on the basis of
the semantics of the x86 language.

A halt decider must compute the mapping from its inputs to an accept or
reject state on the basis of the actual behavior that is actually
specified by these inputs.

P(P) is provably not the actual behavior of the actual input.

--
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 Monday, June 27, 2022 at 2:37:44 PM UTC-4, olcott wrote:
> On 6/27/2022 1:13 PM, Dennis Bush wrote:
> > On Monday, June 27, 2022 at 2:11:45 PM UTC-4, olcott wrote:
> >> On 6/27/2022 1:03 PM, Dennis Bush wrote:
> >>> On Monday, June 27, 2022 at 1:20:39 PM UTC-4, olcott wrote:
> >>>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
> >>>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
> >>>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
> >>>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
> >>>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
> >>>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> *This is the outline of the complete refutation*
> >>>>>>>>>>>>>> *of the only rebuttal that anyone has left*
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>> never reaches the "ret" instruction of P.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
> >>>>>>>>>>>>>> the semantics of the x86 language.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
> >>>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> H does not perform this mapping.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> P(P);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>> [000011f0](01) 55 push ebp
> >>>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [000011f6](01) 50 push eax
> >>>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [000011fa](01) 51 push ecx
> >>>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
> >>>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
> >>>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
> >>>>>>>>>>>>>> [00001209](01) 5d pop ebp
> >>>>>>>>>>>>>> [0000120a](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>> [00001210](01) 55 push ebp
> >>>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
> >>>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
> >>>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
> >>>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001222](01) 5d pop ebp
> >>>>>>>>>>>>>> [00001223](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0020) [00001223]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>>>> address address data code language
> >>>>>>>>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
> >>>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
> >>>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
> >>>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
> >>>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
> >>>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
> >>>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
> >>>>>>>>>>>>>> Address_of_H:1020
> >>>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
> >>>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
> >>>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
> >>>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
> >>>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
> >>>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
> >>>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
> >>>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
> >>>>>>>>>>>>>> recursive emulation.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> FALSE. P contains these instructions:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
> >>>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
> >>>>>>>>>>>>> goto END_OF_CODE;
> >>>>>>>>>>>>> return 0; // Does not halt
> >>>>>>>>>>>>> END_OF_CODE:
> >>>>>>>>>>>>> return 1; // Input has normally terminated
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
> >>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
> >>>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
> >>>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
> >>>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
> >>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
> >>>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
> >>>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
> >>>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
> >>>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
> >>>>>>>>>>>> input never reaches the the "ret" instruction of P.
> >>>>>>>>>>>
> >>>>>>>>>>> Repeating your original point.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> This is the actual behavior of the input to H(P,P).
> >>>>>>>>>>>>
> >>>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> Again, repeating your original point.
> >>>>>>>>>>>
> >>>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
> >>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>> Therefore H(P,P)==0 is correct.
> >>>>>>>>>>>
> >>>>>>>>>>> And again, repeating your original point.
> >>>>>>>>>>>
> >>>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
> >>>>>>>>>>>
> >>>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
> >>>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
> >>>>>>>>>> halt decider correctly predicts that its correctly simulated input will
> >>>>>>>>>> never reach the final state "ret" instruction of this input.
> >>>>>>>>>
> >>>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>> First of all I am not talking about UTM's.
> >>>>>>>> I am talking about x86 emulation.
> >>>>>>>> Try to encode what you mean, here is my guess:
> >>>>>>>>
> >>>>>>>> void P(u32 x)
> >>>>>>>> {
> >>>>>>>> if (emulate_x86(x, x))
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>> }
> >>>>>>>
> >>>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
> >>>>>>>
> >>>>>>> void UTM(u32 x, u32 y)
> >>>>>>> {
> >>>>>>> x(y)
> >>>>>>> }
> >>>>>>>
> >>>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
> >>>>>>>
> >>>>>> A simulating halt decider correctly simulates its input until it
> >>>>>> correctly determines that this simulated input would never reach its
> >>>>>> final state.
> >>>>>
> >>>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
> >>>>>
> >>>> Every simulating decider that correctly simulates its input until it
> >>>> correctly determines that this simulated input would never reach its
> >>>> final state correctly determines the halt status of this input.
> >>>
> >>> And H isn't such a decider, because it does not correctly determine that the input to H(P,P) would never halt as demonstrated by UTM(P,P) halting.
> >>>
> >>> The specification for H:
> >>>
> >>> H(x,y)==0 if and only if x(y) does not halt, and
> >>> H(x,y)==1 if and only if x(y) halts.
> >>>
> >>> H does not meet the specification.
> >>>
> >> The spec is provably incorrect in this case:
> >
> > A spec can't be incorrect. It just is. If it can't be satisfied, then that validates the halting problem proofs that say it can't be satisfied.
>
> A halt decider must compute the mapping from its inputs to an accept or
> reject state on the basis of the actual behavior that is actually
> specified by these inputs.

On 6/27/2022 1:45 PM, Dennis Bush wrote:
> On Monday, June 27, 2022 at 2:37:44 PM UTC-4, olcott wrote:
>> On 6/27/2022 1:13 PM, Dennis Bush wrote:
>>> On Monday, June 27, 2022 at 2:11:45 PM UTC-4, olcott wrote:

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

int main()
{ P(P);
}

_P()
[000011f0](01) 55 push ebp
[000011f1](02) 8bec mov ebp,esp
[000011f3](03) 8b4508 mov eax,[ebp+08]
[000011f6](01) 50 push eax
[000011f7](03) 8b4d08 mov ecx,[ebp+08]
[000011fa](01) 51 push ecx
[000011fb](05) e820feffff call 00001020

[00001200](03) 83c408 add esp,+08
[00001203](02) 85c0 test eax,eax
[00001205](02) 7402 jz 00001209
[00001207](02) ebfe jmp 00001207
[00001209](01) 5d pop ebp
[0000120a](01) c3 ret
Size in bytes:(0027) [0000120a]

_main()
[00001210](01) 55 push ebp
[00001211](02) 8bec mov ebp,esp
[00001213](05) 68f0110000 push 000011f0
[00001218](05) e8d3ffffff call 000011f0
[0000121d](03) 83c404 add esp,+04
[00001220](02) 33c0 xor eax,eax
[00001222](01) 5d pop ebp
[00001223](01) c3 ret
Size in bytes:(0020) [00001223]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001210][00101fba][00000000] 55 push ebp
[00001211][00101fba][00000000] 8bec mov ebp,esp
[00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
[00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
[000011f0][00101fae][00101fba] 55 push ebp // enter executed P
[000011f1][00101fae][00101fba] 8bec mov ebp,esp
[000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
[000011f6][00101faa][000011f0] 50 push eax // push P
[000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
[000011fa][00101fa6][000011f0] 51 push ecx // push P
[000011fb][00101fa2][00001200] e820feffff call 00001020 // call H

Begin Simulation Execution Trace Stored at:21206e
Address_of_H:1020
[000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
[000011f1][0021205a][0021205e] 8bec mov ebp,esp
[000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
[000011f6][00212056][000011f0] 50 push eax // push P
[000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
[000011fa][00212052][000011f0] 51 push ecx // push P
[000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
Infinitely Recursive Simulation Detected Simulation Stopped

H knows its own machine address and on this basis it can easily
examine its stored execution_trace of P (see above) to determine:
(a) P is calling H with the same arguments that H was called with.
(b) No instructions in P could possibly escape this otherwise infinitely
recursive emulation.
(c) H aborts its emulation of P before its call to H is emulated.

[00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
executed P
[00001203][00101fae][00101fba] 85c0 test eax,eax
[00001205][00101fae][00101fba] 7402 jz 00001209
[00001209][00101fb2][0000121d] 5d pop ebp
[0000120a][00101fb6][000011f0] c3 ret // return from
executed P
[0000121d][00101fba][00000000] 83c404 add esp,+04
[00001220][00101fba][00000000] 33c0 xor eax,eax
[00001222][00101fbe][00100000] 5d pop ebp
[00001223][00101fc2][00000000] c3 ret // ret from main
Number of Instructions Executed(878) / 67 = 13 pages

>> A halt decider must compute the mapping from its inputs to an accept or
>> reject state on the basis of the actual behavior that is actually
>> specified by these inputs.
>
> Which is DEFINED to be the behavior of P(P)
>
>>
>> P(P) is provably not the actual behavior of the actual input.
>
> Only if H performed an incorrect simulation.

In other words you disagree with the semantics of the x86 language.

(a) The complete and correct x86 emulation of the input to H(P,P) by H
never reaches the "ret" instruction of P.

(b) The direct execution of P(P) does reach its "ret" instruction.

The above two are proven to be verified facts entirely on the basis of
the semantics of the x86 language and the execution trace shown above.

--
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 Monday, June 27, 2022 at 2:41:50 PM UTC-4, olcott wrote:
> On 6/27/2022 1:08 PM, Dennis Bush wrote:
> > On Monday, June 27, 2022 at 1:59:58 PM UTC-4, olcott wrote:
> >> On 6/27/2022 12:03 PM, Dennis Bush wrote:
> >>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
> >>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
> >>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
> >>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
> >>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
> >>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
> >>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> *This is the outline of the complete refutation*
> >>>>>>>>>>>> *of the only rebuttal that anyone has left*
> >>>>>>>>>>>>
> >>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>> never reaches the "ret" instruction of P.
> >>>>>>>>>>>
> >>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >>>>>>>>>>>
> >>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> >>>>>>>>>>>
> >>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
> >>>>>>>>>>>> the semantics of the x86 language.
> >>>>>>>>>>>
> >>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise..
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>
> >>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
> >>>>>>>>>>>
> >>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
> >>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
> >>>>>>>>>>>
> >>>>>>>>>>> H does not perform this mapping.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input..
> >>>>>>>>>>>
> >>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> P(P);
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> _P()
> >>>>>>>>>>>> [000011f0](01) 55 push ebp
> >>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [000011f6](01) 50 push eax
> >>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>> [000011fa](01) 51 push ecx
> >>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
> >>>>>>>>>>>>
> >>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
> >>>>>>>>>>>> [00001205](02) 7402 jz 00001209
> >>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
> >>>>>>>>>>>> [00001209](01) 5d pop ebp
> >>>>>>>>>>>> [0000120a](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0027) [0000120a]
> >>>>>>>>>>>>
> >>>>>>>>>>>> _main()
> >>>>>>>>>>>> [00001210](01) 55 push ebp
> >>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
> >>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
> >>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
> >>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
> >>>>>>>>>>>> [00001222](01) 5d pop ebp
> >>>>>>>>>>>> [00001223](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0020) [00001223]
> >>>>>>>>>>>>
> >>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>> address address data code language
> >>>>>>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
> >>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
> >>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
> >>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
> >>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
> >>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
> >>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
> >>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
> >>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
> >>>>>>>>>>>>
> >>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
> >>>>>>>>>>>> Address_of_H:1020
> >>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
> >>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
> >>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
> >>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
> >>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
> >>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
> >>>>>>>>>>>>
> >>>>>>>>>>>> H knows its own machine address and on this basis it can easily
> >>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
> >>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
> >>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
> >>>>>>>>>>>> recursive emulation.
> >>>>>>>>>>>
> >>>>>>>>>>> FALSE. P contains these instructions:
> >>>>>>>>>>>
> >>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
> >>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
> >>>>>>>>>>> goto END_OF_CODE;
> >>>>>>>>>>> return 0; // Does not halt
> >>>>>>>>>>> END_OF_CODE:
> >>>>>>>>>>> return 1; // Input has normally terminated
> >>>>>>>>>>>
> >>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
> >>>>>>>>>>>
> >>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
> >>>>>>>>>>>
> >>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
> >>>>>>>>>>>> executed P
> >>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
> >>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
> >>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
> >>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
> >>>>>>>>>>>> executed P
> >>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
> >>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
> >>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
> >>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
> >>>>>>>>>>>
> >>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
> >>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
> >>>>>>>>>> input never reaches the the "ret" instruction of P.
> >>>>>>>>>
> >>>>>>>>> Repeating your original point.
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> This is the actual behavior of the input to H(P,P).
> >>>>>>>>>>
> >>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> Again, repeating your original point.
> >>>>>>>>>
> >>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
> >>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>> specified by these inputs.
> >>>>>>>>>> Therefore H(P,P)==0 is correct.
> >>>>>>>>>
> >>>>>>>>> And again, repeating your original point.
> >>>>>>>>>
> >>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
> >>>>>>>>>
> >>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
> >>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
> >>>>>>>> halt decider correctly predicts that its correctly simulated input will
> >>>>>>>> never reach the final state "ret" instruction of this input.
> >>>>>>>
> >>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>> First of all I am not talking about UTM's.
> >>>>>> I am talking about x86 emulation.
> >>>>>> Try to encode what you mean, here is my guess:
> >>>>>>
> >>>>>> void P(u32 x)
> >>>>>> {
> >>>>>> if (emulate_x86(x, x))
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>> }
> >>>>>
> >>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
> >>>>>
> >>>>> void UTM(u32 x, u32 y)
> >>>>> {
> >>>>> x(y)
> >>>>> }
> >>>>>
> >>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
> >>>>>
> >>>> A simulating halt decider correctly simulates its input until it
> >>>> correctly determines that this simulated input would never reach its
> >>>> final state.
> >>>
> >>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
> >>>
> >> The semantics of the x86 language conclusively proves that H(P,P)
> >> correctly determines/predicts that its complete and correct x86
> >> emulation of its input would never reach the "ret" instruction of P.
> >
> > As previously stated, this is nonsense. Failure to explain *in detail* why the below is wrong will be taken as an admission that it is correct.
> >
> > It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >
> > To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> I NEVER SAID that H does a complete and correct simulation of its input.

On Mon, 27 Jun 2022 13:44:49 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/27/2022 1:20 PM, Mr Flibble wrote:
> > On Mon, 27 Jun 2022 07:05:46 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> *This is the outline of the complete refutation*
> >> *of the only rebuttal that anyone has left*
> >>
> >> (a) The complete and correct x86 emulation of the input to H(P,P)
> >> by H never reaches the "ret" instruction of P.
> >>
> >> (b) The direct execution of P(P) does reach its "ret" instruction.
> >>
> >> The above two are proven to be verified facts entirely on the basis
> >> of the semantics of the x86 language.
> >>
> >> A halt decider must compute the mapping from its inputs to an
> >> accept or reject state on the basis of the actual behavior that is
> >> actually specified by these inputs.
> >>
> >> P(P) is provably not the actual behavior of the actual input.
> >>
> >>
> >>
> >> void P(u32 x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H1((u32)P, (u32)P));
> >> }
> >>
> >> _P()
> >> [0000163a](01) 55 push ebp
> >> [0000163b](02) 8bec mov ebp,esp
> >> [0000163d](03) 8b4508 mov eax,[ebp+08]
> >> [00001640](01) 50 push eax
> >> [00001641](03) 8b4d08 mov ecx,[ebp+08]
> >> [00001644](01) 51 push ecx
> >> [00001645](05) e8f0fdffff call 0000143a // call H
> >> [0000164a](03) 83c408 add esp,+08
> >> [0000164d](02) 85c0 test eax,eax
> >> [0000164f](02) 7402 jz 00001653
> >> [00001651](02) ebfe jmp 00001651
> >> [00001653](01) 5d pop ebp
> >> [00001654](01) c3 ret
> >> Size in bytes:(0027) [00001654]
> >>
> >> _main()
> >> [0000165a](01) 55 push ebp
> >> [0000165b](02) 8bec mov ebp,esp
> >> [0000165d](05) 683a160000 push 0000163a // push P
> >> [00001662](05) 683a160000 push 0000163a // push P
> >> [00001667](05) e8cef9ffff call 0000103a // call H1
> >> [0000166c](03) 83c408 add esp,+08
> >> [0000166f](01) 50 push eax // push return value
> >> [00001670](05) 689b040000 push 0000049b // "Input_Halts = "
> >> [00001675](05) e870eeffff call 000004ea // call Output
> >> [0000167a](03) 83c408 add esp,+08
> >> [0000167d](02) 33c0 xor eax,eax
> >> [0000167f](01) 5d pop ebp
> >> [00001680](01) c3 ret
> >> Size in bytes:(0039) [00001680]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> [0000165a][001026a9][00000000] 55 push ebp
> >> [0000165b][001026a9][00000000] 8bec mov ebp,esp
> >> [0000165d][001026a5][0000163a] 683a160000 push 0000163a // push P
> >> [00001662][001026a1][0000163a] 683a160000 push 0000163a // push P
> >> [00001667][0010269d][0000166c] e8cef9ffff call 0000103a // call H1
> >>
> >> H1: Begin Simulation Execution Trace Stored at:21275d
> >> Address_of_H1:103a
> >> [0000163a][00212749][0021274d] 55 push ebp
> >> [0000163b][00212749][0021274d] 8bec mov ebp,esp
> >> [0000163d][00212749][0021274d] 8b4508 mov eax,[ebp+08]
> >> [00001640][00212745][0000163a] 50 push eax // push P
> >> [00001641][00212745][0000163a] 8b4d08 mov ecx,[ebp+08]
> >> [00001644][00212741][0000163a] 51 push ecx // push P
> >> [00001645][0021273d][0000164a] e8f0fdffff call 0000143a // call H
> >>
> >> H: Begin Simulation Execution Trace Stored at:2285c5
> >> Address_of_H:143a
> >> [0000163a][002285b1][002285b5] 55 push ebp
> >> [0000163b][002285b1][002285b5] 8bec mov ebp,esp
> >> [0000163d][002285b1][002285b5] 8b4508 mov eax,[ebp+08]
> >> [00001640][002285ad][0000163a] 50 push eax // push P
> >> [00001641][002285ad][0000163a] 8b4d08 mov ecx,[ebp+08]
> >> [00001644][002285a9][0000163a] 51 push ecx // push P
> >> [00001645][002285a5][0000164a] e8f0fdffff call 0000143a // call H
> >> H: Infinitely Recursive Simulation Detected Simulation Stopped
> >>
> >> [0000164a][00212749][0021274d] 83c408 add esp,+08
> >> [0000164d][00212749][0021274d] 85c0 test eax,eax
> >> [0000164f][00212749][0021274d] 7402 jz 00001653
> >> [00001653][0021274d][0000111e] 5d pop ebp
> >> [00001654][00212751][0000163a] c3 ret
> >> H1: End Simulation Input Terminated Normally
> >>
> >> [0000166c][001026a9][00000000] 83c408 add esp,+08
> >> [0000166f][001026a5][00000001] 50 push eax // return
> >> value [00001670][001026a1][0000049b] 689b040000 push 0000049b //
> >> "Input_Halts = " [00001675][001026a1][0000049b] e870eeffff call
> >> 000004ea // call Output Input_Halts = 1
> >> [0000167a][001026a9][00000000] 83c408 add esp,+08
> >> [0000167d][001026a9][00000000] 33c0 xor eax,eax
> >> [0000167f][001026ad][00100000] 5d pop ebp
> >> [00001680][001026b1][00000004] c3 ret
> >> Number of Instructions Executed(409590) == 6113 Pages
> >
> > Why the new H/H1 dichotomy? Are you finally admitting that the
> > decider that main() calls is different to the decider that P would
> > call if you weren't erroneously aborting the simulation?
> >
> > /Flibble
> >
>
> The above example proves the following:
>
> (a) The complete and correct x86 emulation of the input to H(P,P) by
> H never reaches the "ret" instruction of P.
>
> (b) The direct execution of P(P) does reach its "ret" instruction.

Then H returned the wrong answer. See [Strachey, 1965].

/Flibble

On 6/27/2022 1:51 PM, Dennis Bush wrote:
> On Monday, June 27, 2022 at 2:41:50 PM UTC-4, olcott wrote:
>> On 6/27/2022 1:08 PM, Dennis Bush wrote:
>>> On Monday, June 27, 2022 at 1:59:58 PM UTC-4, olcott wrote:
>>>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
>>>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
>>>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
>>>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
>>>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
>>>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
>>>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> *This is the outline of the complete refutation*
>>>>>>>>>>>>>> *of the only rebuttal that anyone has left*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>> never reaches the "ret" instruction of P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
>>>>>>>>>>>>>> the semantics of the x86 language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
>>>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H does not perform this mapping.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>> [000011f0](01) 55 push ebp
>>>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000011f6](01) 50 push eax
>>>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000011fa](01) 51 push ecx
>>>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
>>>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
>>>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
>>>>>>>>>>>>>> [00001209](01) 5d pop ebp
>>>>>>>>>>>>>> [0000120a](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>> [00001210](01) 55 push ebp
>>>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
>>>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
>>>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
>>>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001222](01) 5d pop ebp
>>>>>>>>>>>>>> [00001223](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0020) [00001223]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
>>>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
>>>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
>>>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
>>>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
>>>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
>>>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
>>>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
>>>>>>>>>>>>>> Address_of_H:1020
>>>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
>>>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
>>>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
>>>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
>>>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
>>>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
>>>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
>>>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
>>>>>>>>>>>>>> recursive emulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FALSE. P contains these instructions:
>>>>>>>>>>>>>
>>>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
>>>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
>>>>>>>>>>>>> goto END_OF_CODE;
>>>>>>>>>>>>> return 0; // Does not halt
>>>>>>>>>>>>> END_OF_CODE:
>>>>>>>>>>>>> return 1; // Input has normally terminated
>>>>>>>>>>>>>
>>>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
>>>>>>>>>>>>>
>>>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
>>>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
>>>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
>>>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
>>>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
>>>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
>>>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
>>>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
>>>>>>>>>>>> input never reaches the the "ret" instruction of P.
>>>>>>>>>>>
>>>>>>>>>>> Repeating your original point.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This is the actual behavior of the input to H(P,P).
>>>>>>>>>>>>
>>>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Again, repeating your original point.
>>>>>>>>>>>
>>>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>> Therefore H(P,P)==0 is correct.
>>>>>>>>>>>
>>>>>>>>>>> And again, repeating your original point.
>>>>>>>>>>>
>>>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
>>>>>>>>>>>
>>>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
>>>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
>>>>>>>>>> halt decider correctly predicts that its correctly simulated input will
>>>>>>>>>> never reach the final state "ret" instruction of this input.
>>>>>>>>>
>>>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>> First of all I am not talking about UTM's.
>>>>>>>> I am talking about x86 emulation.
>>>>>>>> Try to encode what you mean, here is my guess:
>>>>>>>>
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>> if (emulate_x86(x, x))
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>> }
>>>>>>>
>>>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
>>>>>>>
>>>>>>> void UTM(u32 x, u32 y)
>>>>>>> {
>>>>>>> x(y)
>>>>>>> }
>>>>>>>
>>>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
>>>>>>>
>>>>>> A simulating halt decider correctly simulates its input until it
>>>>>> correctly determines that this simulated input would never reach its
>>>>>> final state.
>>>>>
>>>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
>>>>>
>>>> The semantics of the x86 language conclusively proves that H(P,P)
>>>> correctly determines/predicts that its complete and correct x86
>>>> emulation of its input would never reach the "ret" instruction of P.
>>>
>>> As previously stated, this is nonsense. Failure to explain *in detail* why the below is wrong will be taken as an admission that it is correct.
>>>
>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>>>
>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
>> I NEVER SAID that H does a complete and correct simulation of its input.
>
> Yes you did:
>
>> a) The complete and correct x86 emulation of the input to H(P,P) by H never reaches the "ret" instruction of P.
>

On 6/27/2022 1:53 PM, Mr Flibble wrote:
> On Mon, 27 Jun 2022 13:44:49 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/27/2022 1:20 PM, Mr Flibble wrote:
>>> On Mon, 27 Jun 2022 07:05:46 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> *This is the outline of the complete refutation*
>>>> *of the only rebuttal that anyone has left*
>>>>
>>>> (a) The complete and correct x86 emulation of the input to H(P,P)
>>>> by H never reaches the "ret" instruction of P.
>>>>
>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>
>>>> The above two are proven to be verified facts entirely on the basis
>>>> of the semantics of the x86 language.
>>>>
>>>> A halt decider must compute the mapping from its inputs to an
>>>> accept or reject state on the basis of the actual behavior that is
>>>> actually specified by these inputs.
>>>>
>>>> P(P) is provably not the actual behavior of the actual input.
>>>>
>>>>
>>>>
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>>>> }
>>>>
>>>> _P()
>>>> [0000163a](01) 55 push ebp
>>>> [0000163b](02) 8bec mov ebp,esp
>>>> [0000163d](03) 8b4508 mov eax,[ebp+08]
>>>> [00001640](01) 50 push eax
>>>> [00001641](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00001644](01) 51 push ecx
>>>> [00001645](05) e8f0fdffff call 0000143a // call H
>>>> [0000164a](03) 83c408 add esp,+08
>>>> [0000164d](02) 85c0 test eax,eax
>>>> [0000164f](02) 7402 jz 00001653
>>>> [00001651](02) ebfe jmp 00001651
>>>> [00001653](01) 5d pop ebp
>>>> [00001654](01) c3 ret
>>>> Size in bytes:(0027) [00001654]
>>>>
>>>> _main()
>>>> [0000165a](01) 55 push ebp
>>>> [0000165b](02) 8bec mov ebp,esp
>>>> [0000165d](05) 683a160000 push 0000163a // push P
>>>> [00001662](05) 683a160000 push 0000163a // push P
>>>> [00001667](05) e8cef9ffff call 0000103a // call H1
>>>> [0000166c](03) 83c408 add esp,+08
>>>> [0000166f](01) 50 push eax // push return value
>>>> [00001670](05) 689b040000 push 0000049b // "Input_Halts = "
>>>> [00001675](05) e870eeffff call 000004ea // call Output
>>>> [0000167a](03) 83c408 add esp,+08
>>>> [0000167d](02) 33c0 xor eax,eax
>>>> [0000167f](01) 5d pop ebp
>>>> [00001680](01) c3 ret
>>>> Size in bytes:(0039) [00001680]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> [0000165a][001026a9][00000000] 55 push ebp
>>>> [0000165b][001026a9][00000000] 8bec mov ebp,esp
>>>> [0000165d][001026a5][0000163a] 683a160000 push 0000163a // push P
>>>> [00001662][001026a1][0000163a] 683a160000 push 0000163a // push P
>>>> [00001667][0010269d][0000166c] e8cef9ffff call 0000103a // call H1
>>>>
>>>> H1: Begin Simulation Execution Trace Stored at:21275d
>>>> Address_of_H1:103a
>>>> [0000163a][00212749][0021274d] 55 push ebp
>>>> [0000163b][00212749][0021274d] 8bec mov ebp,esp
>>>> [0000163d][00212749][0021274d] 8b4508 mov eax,[ebp+08]
>>>> [00001640][00212745][0000163a] 50 push eax // push P
>>>> [00001641][00212745][0000163a] 8b4d08 mov ecx,[ebp+08]
>>>> [00001644][00212741][0000163a] 51 push ecx // push P
>>>> [00001645][0021273d][0000164a] e8f0fdffff call 0000143a // call H
>>>>
>>>> H: Begin Simulation Execution Trace Stored at:2285c5
>>>> Address_of_H:143a
>>>> [0000163a][002285b1][002285b5] 55 push ebp
>>>> [0000163b][002285b1][002285b5] 8bec mov ebp,esp
>>>> [0000163d][002285b1][002285b5] 8b4508 mov eax,[ebp+08]
>>>> [00001640][002285ad][0000163a] 50 push eax // push P
>>>> [00001641][002285ad][0000163a] 8b4d08 mov ecx,[ebp+08]
>>>> [00001644][002285a9][0000163a] 51 push ecx // push P
>>>> [00001645][002285a5][0000164a] e8f0fdffff call 0000143a // call H
>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>
>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>> [0000164d][00212749][0021274d] 85c0 test eax,eax
>>>> [0000164f][00212749][0021274d] 7402 jz 00001653
>>>> [00001653][0021274d][0000111e] 5d pop ebp
>>>> [00001654][00212751][0000163a] c3 ret
>>>> H1: End Simulation Input Terminated Normally
>>>>
>>>> [0000166c][001026a9][00000000] 83c408 add esp,+08
>>>> [0000166f][001026a5][00000001] 50 push eax // return
>>>> value [00001670][001026a1][0000049b] 689b040000 push 0000049b //
>>>> "Input_Halts = " [00001675][001026a1][0000049b] e870eeffff call
>>>> 000004ea // call Output Input_Halts = 1
>>>> [0000167a][001026a9][00000000] 83c408 add esp,+08
>>>> [0000167d][001026a9][00000000] 33c0 xor eax,eax
>>>> [0000167f][001026ad][00100000] 5d pop ebp
>>>> [00001680][001026b1][00000004] c3 ret
>>>> Number of Instructions Executed(409590) == 6113 Pages
>>>
>>> Why the new H/H1 dichotomy? Are you finally admitting that the
>>> decider that main() calls is different to the decider that P would
>>> call if you weren't erroneously aborting the simulation?
>>>
>>> /Flibble
>>>
>>
>> The above example proves the following:
>>
>> (a) The complete and correct x86 emulation of the input to H(P,P) by
>> H never reaches the "ret" instruction of P.
>>
>> (b) The direct execution of P(P) does reach its "ret" instruction.
>
> Then H returned the wrong answer. See [Strachey, 1965].
>
> /Flibble
>

So your rebuttals simply ignore that I proved you are wrong?

// rec routine P
// §L :if T[P] go to L
// Return §
// https://academic.oup.com/comjnl/article/7/4/313/354243
void Strachey_P()
{ L:if (T(Strachey_P))
goto L;
return;
}

int main()
{ Output("Input_Halts = ", T(Strachey_P));
}

_Strachey_P()
[000015b2](01) 55 push ebp
[000015b3](02) 8bec mov ebp,esp
[000015b5](05) 68b2150000 push 000015b2 // push Strachey_P
[000015ba](05) e813fdffff call 000012d2 // call T
[000015bf](03) 83c404 add esp,+04
[000015c2](02) 85c0 test eax,eax
[000015c4](02) 7402 jz 000015c8
[000015c6](02) ebed jmp 000015b5
[000015c8](01) 5d pop ebp
[000015c9](01) c3 ret
Size in bytes:(0024) [000015c9]

_main()
[000015d2](01) 55 push ebp
[000015d3](02) 8bec mov ebp,esp
[000015d5](05) 68b2150000 push 000015b2 // push Strachey_P
[000015da](05) e8f3fcffff call 000012d2 // call T
[000015df](03) 83c404 add esp,+04
[000015e2](01) 50 push eax
[000015e3](05) 6833040000 push 00000433
[000015e8](05) e895eeffff call 00000482
[000015ed](03) 83c408 add esp,+08
[000015f0](02) 33c0 xor eax,eax
[000015f2](01) 5d pop ebp
[000015f3](01) c3 ret
Size in bytes:(0034) [000015f3]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000015d2][001025c6][00000000] 55 push ebp
[000015d3][001025c6][00000000] 8bec mov ebp,esp
[000015d5][001025c2][000015b2] 68b2150000 push 000015b2 // push Strachey_P
[000015da][001025be][000015df] e8f3fcffff call 000012d2 // call T

On Monday, June 27, 2022 at 3:02:47 PM UTC-4, olcott wrote:
> On 6/27/2022 1:51 PM, Dennis Bush wrote:
> > On Monday, June 27, 2022 at 2:41:50 PM UTC-4, olcott wrote:
> >> On 6/27/2022 1:08 PM, Dennis Bush wrote:
> >>> On Monday, June 27, 2022 at 1:59:58 PM UTC-4, olcott wrote:
> >>>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
> >>>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
> >>>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
> >>>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
> >>>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
> >>>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> *This is the outline of the complete refutation*
> >>>>>>>>>>>>>> *of the only rebuttal that anyone has left*
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>> never reaches the "ret" instruction of P.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
> >>>>>>>>>>>>>> the semantics of the x86 language.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
> >>>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> H does not perform this mapping.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> P(P);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>> [000011f0](01) 55 push ebp
> >>>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [000011f6](01) 50 push eax
> >>>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [000011fa](01) 51 push ecx
> >>>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
> >>>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
> >>>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
> >>>>>>>>>>>>>> [00001209](01) 5d pop ebp
> >>>>>>>>>>>>>> [0000120a](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>> [00001210](01) 55 push ebp
> >>>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
> >>>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
> >>>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
> >>>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001222](01) 5d pop ebp
> >>>>>>>>>>>>>> [00001223](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0020) [00001223]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> machine stack stack machine assembly
> >>>>>>>>>>>>>> address address data code language
> >>>>>>>>>>>>>> ======== ======== ======== ========= =============
> >>>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
> >>>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
> >>>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
> >>>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
> >>>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
> >>>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
> >>>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
> >>>>>>>>>>>>>> Address_of_H:1020
> >>>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
> >>>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
> >>>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
> >>>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
> >>>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
> >>>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
> >>>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
> >>>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
> >>>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
> >>>>>>>>>>>>>> recursive emulation.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> FALSE. P contains these instructions:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
> >>>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
> >>>>>>>>>>>>> goto END_OF_CODE;
> >>>>>>>>>>>>> return 0; // Does not halt
> >>>>>>>>>>>>> END_OF_CODE:
> >>>>>>>>>>>>> return 1; // Input has normally terminated
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
> >>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
> >>>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
> >>>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
> >>>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
> >>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
> >>>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
> >>>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
> >>>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
> >>>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
> >>>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
> >>>>>>>>>>>> input never reaches the the "ret" instruction of P.
> >>>>>>>>>>>
> >>>>>>>>>>> Repeating your original point.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> This is the actual behavior of the input to H(P,P).
> >>>>>>>>>>>>
> >>>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> Again, repeating your original point.
> >>>>>>>>>>>
> >>>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
> >>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
> >>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
> >>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>> Therefore H(P,P)==0 is correct.
> >>>>>>>>>>>
> >>>>>>>>>>> And again, repeating your original point.
> >>>>>>>>>>>
> >>>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
> >>>>>>>>>>>
> >>>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
> >>>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
> >>>>>>>>>> halt decider correctly predicts that its correctly simulated input will
> >>>>>>>>>> never reach the final state "ret" instruction of this input.
> >>>>>>>>>
> >>>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
> >>>>>>>> First of all I am not talking about UTM's.
> >>>>>>>> I am talking about x86 emulation.
> >>>>>>>> Try to encode what you mean, here is my guess:
> >>>>>>>>
> >>>>>>>> void P(u32 x)
> >>>>>>>> {
> >>>>>>>> if (emulate_x86(x, x))
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
> >>>>>>>> }
> >>>>>>>
> >>>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
> >>>>>>>
> >>>>>>> void UTM(u32 x, u32 y)
> >>>>>>> {
> >>>>>>> x(y)
> >>>>>>> }
> >>>>>>>
> >>>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
> >>>>>>>
> >>>>>> A simulating halt decider correctly simulates its input until it
> >>>>>> correctly determines that this simulated input would never reach its
> >>>>>> final state.
> >>>>>
> >>>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
> >>>>>
> >>>> The semantics of the x86 language conclusively proves that H(P,P)
> >>>> correctly determines/predicts that its complete and correct x86
> >>>> emulation of its input would never reach the "ret" instruction of P.
> >>>
> >>> As previously stated, this is nonsense. Failure to explain *in detail* why the below is wrong will be taken as an admission that it is correct.
> >>>
> >>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
> >>>
> >>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
> >> I NEVER SAID that H does a complete and correct simulation of its input.
> >
> > Yes you did:
> >
> >> a) The complete and correct x86 emulation of the input to H(P,P) by H never reaches the "ret" instruction of P.
> >
> This does not say that H does a complete emulation.
> A simulating halt decider correctly simulates its input until it
> correctly determines that this simulated input would never reach its
> final state.

On Mon, 27 Jun 2022 14:06:42 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/27/2022 1:53 PM, Mr Flibble wrote:
> > On Mon, 27 Jun 2022 13:44:49 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/27/2022 1:20 PM, Mr Flibble wrote:
> >>> On Mon, 27 Jun 2022 07:05:46 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> *This is the outline of the complete refutation*
> >>>> *of the only rebuttal that anyone has left*
> >>>>
> >>>> (a) The complete and correct x86 emulation of the input to H(P,P)
> >>>> by H never reaches the "ret" instruction of P.
> >>>>
> >>>> (b) The direct execution of P(P) does reach its "ret"
> >>>> instruction.
> >>>>
> >>>> The above two are proven to be verified facts entirely on the
> >>>> basis of the semantics of the x86 language.
> >>>>
> >>>> A halt decider must compute the mapping from its inputs to an
> >>>> accept or reject state on the basis of the actual behavior that
> >>>> is actually specified by these inputs.
> >>>>
> >>>> P(P) is provably not the actual behavior of the actual input.
> >>>>
> >>>>
> >>>>
> >>>> void P(u32 x)
> >>>> {
> >>>> if (H(x, x))
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H1((u32)P, (u32)P));
> >>>> }
> >>>>
> >>>> _P()
> >>>> [0000163a](01) 55 push ebp
> >>>> [0000163b](02) 8bec mov ebp,esp
> >>>> [0000163d](03) 8b4508 mov eax,[ebp+08]
> >>>> [00001640](01) 50 push eax
> >>>> [00001641](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [00001644](01) 51 push ecx
> >>>> [00001645](05) e8f0fdffff call 0000143a // call H
> >>>> [0000164a](03) 83c408 add esp,+08
> >>>> [0000164d](02) 85c0 test eax,eax
> >>>> [0000164f](02) 7402 jz 00001653
> >>>> [00001651](02) ebfe jmp 00001651
> >>>> [00001653](01) 5d pop ebp
> >>>> [00001654](01) c3 ret
> >>>> Size in bytes:(0027) [00001654]
> >>>>
> >>>> _main()
> >>>> [0000165a](01) 55 push ebp
> >>>> [0000165b](02) 8bec mov ebp,esp
> >>>> [0000165d](05) 683a160000 push 0000163a // push P
> >>>> [00001662](05) 683a160000 push 0000163a // push P
> >>>> [00001667](05) e8cef9ffff call 0000103a // call H1
> >>>> [0000166c](03) 83c408 add esp,+08
> >>>> [0000166f](01) 50 push eax // push return
> >>>> value [00001670](05) 689b040000 push 0000049b //
> >>>> "Input_Halts = " [00001675](05) e870eeffff call 000004ea
> >>>> // call Output [0000167a](03) 83c408 add esp,+08
> >>>> [0000167d](02) 33c0 xor eax,eax
> >>>> [0000167f](01) 5d pop ebp
> >>>> [00001680](01) c3 ret
> >>>> Size in bytes:(0039) [00001680]
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= ============> >>>> [0000165a][001026a9][00000000] 55 push ebp
> >>>> [0000165b][001026a9][00000000] 8bec mov ebp,esp
> >>>> [0000165d][001026a5][0000163a] 683a160000 push 0000163a // push P
> >>>> [00001662][001026a1][0000163a] 683a160000 push 0000163a // push P
> >>>> [00001667][0010269d][0000166c] e8cef9ffff call 0000103a // call
> >>>> H1
> >>>>
> >>>> H1: Begin Simulation Execution Trace Stored at:21275d
> >>>> Address_of_H1:103a
> >>>> [0000163a][00212749][0021274d] 55 push ebp
> >>>> [0000163b][00212749][0021274d] 8bec mov ebp,esp
> >>>> [0000163d][00212749][0021274d] 8b4508 mov eax,[ebp+08]
> >>>> [00001640][00212745][0000163a] 50 push eax // push P
> >>>> [00001641][00212745][0000163a] 8b4d08 mov ecx,[ebp+08]
> >>>> [00001644][00212741][0000163a] 51 push ecx // push P
> >>>> [00001645][0021273d][0000164a] e8f0fdffff call 0000143a // call H
> >>>>
> >>>> H: Begin Simulation Execution Trace Stored at:2285c5
> >>>> Address_of_H:143a
> >>>> [0000163a][002285b1][002285b5] 55 push ebp
> >>>> [0000163b][002285b1][002285b5] 8bec mov ebp,esp
> >>>> [0000163d][002285b1][002285b5] 8b4508 mov eax,[ebp+08]
> >>>> [00001640][002285ad][0000163a] 50 push eax // push P
> >>>> [00001641][002285ad][0000163a] 8b4d08 mov ecx,[ebp+08]
> >>>> [00001644][002285a9][0000163a] 51 push ecx // push P
> >>>> [00001645][002285a5][0000164a] e8f0fdffff call 0000143a // call H
> >>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
> >>>>
> >>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
> >>>> [0000164d][00212749][0021274d] 85c0 test eax,eax
> >>>> [0000164f][00212749][0021274d] 7402 jz 00001653
> >>>> [00001653][0021274d][0000111e] 5d pop ebp
> >>>> [00001654][00212751][0000163a] c3 ret
> >>>> H1: End Simulation Input Terminated Normally
> >>>>
> >>>> [0000166c][001026a9][00000000] 83c408 add esp,+08
> >>>> [0000166f][001026a5][00000001] 50 push eax // return
> >>>> value [00001670][001026a1][0000049b] 689b040000 push 0000049b //
> >>>> "Input_Halts = " [00001675][001026a1][0000049b] e870eeffff call
> >>>> 000004ea // call Output Input_Halts = 1
> >>>> [0000167a][001026a9][00000000] 83c408 add esp,+08
> >>>> [0000167d][001026a9][00000000] 33c0 xor eax,eax
> >>>> [0000167f][001026ad][00100000] 5d pop ebp
> >>>> [00001680][001026b1][00000004] c3 ret
> >>>> Number of Instructions Executed(409590) == 6113 Pages
> >>>
> >>> Why the new H/H1 dichotomy? Are you finally admitting that the
> >>> decider that main() calls is different to the decider that P would
> >>> call if you weren't erroneously aborting the simulation?
> >>>
> >>> /Flibble
> >>>
> >>
> >> The above example proves the following:
> >>
> >> (a) The complete and correct x86 emulation of the input to H(P,P)
> >> by H never reaches the "ret" instruction of P.
> >>
> >> (b) The direct execution of P(P) does reach its "ret" instruction.
> >>
> >
> > Then H returned the wrong answer. See [Strachey, 1965].
> >
> > /Flibble
> >
>
> So your rebuttals simply ignore that I proved you are wrong?
>
> // rec routine P
> // §L :if T[P] go to L
> // Return §
> // https://academic.oup.com/comjnl/article/7/4/313/354243
> void Strachey_P()
> {
> L:if (T(Strachey_P))
> goto L;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", T(Strachey_P));
> }
>
> _Strachey_P()
> [000015b2](01) 55 push ebp
> [000015b3](02) 8bec mov ebp,esp
> [000015b5](05) 68b2150000 push 000015b2 // push Strachey_P
> [000015ba](05) e813fdffff call 000012d2 // call T
> [000015bf](03) 83c404 add esp,+04
> [000015c2](02) 85c0 test eax,eax
> [000015c4](02) 7402 jz 000015c8
> [000015c6](02) ebed jmp 000015b5
> [000015c8](01) 5d pop ebp
> [000015c9](01) c3 ret
> Size in bytes:(0024) [000015c9]
>
> _main()
> [000015d2](01) 55 push ebp
> [000015d3](02) 8bec mov ebp,esp
> [000015d5](05) 68b2150000 push 000015b2 // push Strachey_P
> [000015da](05) e8f3fcffff call 000012d2 // call T
> [000015df](03) 83c404 add esp,+04
> [000015e2](01) 50 push eax
> [000015e3](05) 6833040000 push 00000433
> [000015e8](05) e895eeffff call 00000482
> [000015ed](03) 83c408 add esp,+08
> [000015f0](02) 33c0 xor eax,eax
> [000015f2](01) 5d pop ebp
> [000015f3](01) c3 ret
> Size in bytes:(0034) [000015f3]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> [000015d2][001025c6][00000000] 55 push ebp
> [000015d3][001025c6][00000000] 8bec mov ebp,esp
> [000015d5][001025c2][000015b2] 68b2150000 push 000015b2 // push
> Strachey_P [000015da][001025be][000015df] e8f3fcffff call 000012d2 //
> call T
>
> Begin Simulation Execution Trace Stored at:21267a
> Address_of_T:12d2
> [000015b2][0021266a][0021266e] 55 push ebp
> [000015b3][0021266a][0021266e] 8bec mov ebp,esp
> [000015b5][00212666][000015b2] 68b2150000 push 000015b2 // push
> Strachey_P [000015ba][00212662][000015bf] e813fdffff call 000012d2 //
> call T Infinitely Recursive Simulation Detected Simulation Stopped
>
> T knows its own machine address and on this basis it can easily
> examine its stored execution_trace of Strachey_P (see above) to
> determine: (a) Strachey_P is calling T with the same arguments that T
> was called with. (b) No instructions in Strachey_P could possibly
> escape this otherwise infinitely recursive emulation.
> (c) T aborts its emulation of Strachey_P before its call to T is
> emulated.
>
> [000015df][001025c6][00000000] 83c404 add esp,+04
> [000015e2][001025c2][00000000] 50 push eax
> [000015e3][001025be][00000433] 6833040000 push 00000433
> [000015e8][001025be][00000433] e895eeffff call 00000482
> Input_Halts = 0
> [000015ed][001025c6][00000000] 83c408 add esp,+08
> [000015f0][001025c6][00000000] 33c0 xor eax,eax
> [000015f2][001025ca][00100000] 5d pop ebp
> [000015f3][001025ce][00000004] c3 ret
> Number of Instructions Executed(528) == 8 Pages

Click here to read the complete article

On 6/27/2022 2:13 PM, Dennis Bush wrote:
> On Monday, June 27, 2022 at 3:02:47 PM UTC-4, olcott wrote:
>> On 6/27/2022 1:51 PM, Dennis Bush wrote:
>>> On Monday, June 27, 2022 at 2:41:50 PM UTC-4, olcott wrote:
>>>> On 6/27/2022 1:08 PM, Dennis Bush wrote:
>>>>> On Monday, June 27, 2022 at 1:59:58 PM UTC-4, olcott wrote:
>>>>>> On 6/27/2022 12:03 PM, Dennis Bush wrote:
>>>>>>> On Monday, June 27, 2022 at 9:28:22 AM UTC-4, olcott wrote:
>>>>>>>> On 6/27/2022 7:58 AM, Dennis Bush wrote:
>>>>>>>>> On Monday, June 27, 2022 at 8:50:05 AM UTC-4, olcott wrote:
>>>>>>>>>> On 6/27/2022 7:40 AM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, June 27, 2022 at 8:34:22 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/27/2022 7:26 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, June 27, 2022 at 8:14:31 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 6/27/2022 6:57 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Monday, June 27, 2022 at 7:11:21 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> *This is the outline of the complete refutation*
>>>>>>>>>>>>>>>> *of the only rebuttal that anyone has left*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>> never reaches the "ret" instruction of P.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What *does* perform a complete and correct emulation of the input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above two are proven to be verified facts entirely on the basis of
>>>>>>>>>>>>>>>> the semantics of the x86 language.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A nonsense statement can't be a "fact", verified or otherwise.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which for H(P,P) is BY DEFINITION is the behavior of P(P). The halting problem says that H MUST implement the following mapping (i.e. the halting function):
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H(x,y)==1 if and only if x(y) halts, and
>>>>>>>>>>>>>>> H(x,y)==0 if and only if x(y) does not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H does not perform this mapping.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> P(P) is provably not the actual behavior of the actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is BY DEFINITION. So if H comes up with something different that means it did something wrong, specifically it aborted a halting computation too soon.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> P(P);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>> [000011f0](01) 55 push ebp
>>>>>>>>>>>>>>>> [000011f1](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000011f3](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000011f6](01) 50 push eax
>>>>>>>>>>>>>>>> [000011f7](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [000011fa](01) 51 push ecx
>>>>>>>>>>>>>>>> [000011fb](05) e820feffff call 00001020
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [00001200](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001203](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>> [00001205](02) 7402 jz 00001209
>>>>>>>>>>>>>>>> [00001207](02) ebfe jmp 00001207
>>>>>>>>>>>>>>>> [00001209](01) 5d pop ebp
>>>>>>>>>>>>>>>> [0000120a](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000120a]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>> [00001210](01) 55 push ebp
>>>>>>>>>>>>>>>> [00001211](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001213](05) 68f0110000 push 000011f0
>>>>>>>>>>>>>>>> [00001218](05) e8d3ffffff call 000011f0
>>>>>>>>>>>>>>>> [0000121d](03) 83c404 add esp,+04
>>>>>>>>>>>>>>>> [00001220](02) 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [00001222](01) 5d pop ebp
>>>>>>>>>>>>>>>> [00001223](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0020) [00001223]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>>>>>> [00001210][00101fba][00000000] 55 push ebp
>>>>>>>>>>>>>>>> [00001211][00101fba][00000000] 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001213][00101fb6][000011f0] 68f0110000 push 000011f0 // push P
>>>>>>>>>>>>>>>> [00001218][00101fb2][0000121d] e8d3ffffff call 000011f0 // call P
>>>>>>>>>>>>>>>> [000011f0][00101fae][00101fba] 55 push ebp // enter executed P
>>>>>>>>>>>>>>>> [000011f1][00101fae][00101fba] 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000011f3][00101fae][00101fba] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000011f6][00101faa][000011f0] 50 push eax // push P
>>>>>>>>>>>>>>>> [000011f7][00101faa][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [000011fa][00101fa6][000011f0] 51 push ecx // push P
>>>>>>>>>>>>>>>> [000011fb][00101fa2][00001200] e820feffff call 00001020 // call H
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Begin Simulation Execution Trace Stored at:21206e
>>>>>>>>>>>>>>>> Address_of_H:1020
>>>>>>>>>>>>>>>> [000011f0][0021205a][0021205e] 55 push ebp // enter emulated P
>>>>>>>>>>>>>>>> [000011f1][0021205a][0021205e] 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [000011f3][0021205a][0021205e] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [000011f6][00212056][000011f0] 50 push eax // push P
>>>>>>>>>>>>>>>> [000011f7][00212056][000011f0] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [000011fa][00212052][000011f0] 51 push ecx // push P
>>>>>>>>>>>>>>>> [000011fb][0021204e][00001200] e820feffff call 00001020 // call emulated H
>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H knows its own machine address and on this basis it can easily
>>>>>>>>>>>>>>>> examine its stored execution_trace of P (see above) to determine:
>>>>>>>>>>>>>>>> (a) P is calling H with the same arguments that H was called with.
>>>>>>>>>>>>>>>> (b) No instructions in P could possibly escape this otherwise infinitely
>>>>>>>>>>>>>>>> recursive emulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FALSE. P contains these instructions:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> if (Decide_Halting(&execution_trace, &decoded, code_end, &master_state,
>>>>>>>>>>>>>>> &slave_state, &slave_stack, Address_of_H, P, I))
>>>>>>>>>>>>>>> goto END_OF_CODE;
>>>>>>>>>>>>>>> return 0; // Does not halt
>>>>>>>>>>>>>>> END_OF_CODE:
>>>>>>>>>>>>>>> return 1; // Input has normally terminated
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That *can* and *do* prevent infinite recursive emulation in a *correct* and *complete* emulation
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (c) H aborts its emulation of P before its call to H is emulated.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And in doing so it fails to see that the call to H, since H is a computation, will aborts *its* simulation of P and return 0 to the outer P being emulated, which would cause it to halt, making H(P,P)==0 wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [00001200][00101fae][00101fba] 83c408 add esp,+08 // return to
>>>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>>>> [00001203][00101fae][00101fba] 85c0 test eax,eax
>>>>>>>>>>>>>>>> [00001205][00101fae][00101fba] 7402 jz 00001209
>>>>>>>>>>>>>>>> [00001209][00101fb2][0000121d] 5d pop ebp
>>>>>>>>>>>>>>>> [0000120a][00101fb6][000011f0] c3 ret // return from
>>>>>>>>>>>>>>>> executed P
>>>>>>>>>>>>>>>> [0000121d][00101fba][00000000] 83c404 add esp,+04
>>>>>>>>>>>>>>>> [00001220][00101fba][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>>>> [00001222][00101fbe][00100000] 5d pop ebp
>>>>>>>>>>>>>>>> [00001223][00101fc2][00000000] c3 ret // ret from main
>>>>>>>>>>>>>>>> Number of Instructions Executed(878) / 67 = 13 pages
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've stated in detail why you're wrong. Now you need to explain in detail why I'm wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Failure to do so, which includes simply restating your original point, will be taken as admission that what I've stated is correct.
>>>>>>>>>>>>>> H correctly predicts that its complete and correct x86 emulation of its
>>>>>>>>>>>>>> input never reaches the the "ret" instruction of P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Repeating your original point.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is the actual behavior of the input to H(P,P).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> P(P) is not the actual behavior of the input to H(P,P).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again, repeating your original point.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Never reaching the "ret" instruction means that P does not halt.
>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an accept or
>>>>>>>>>>>>>> reject state on the basis of the actual behavior that is actually
>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>> Therefore H(P,P)==0 is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And again, repeating your original point.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So no explanation as to why I'm wrong, just a repetition of your original points.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That means you accept that what I've said is true, and that H(P,P)==0 is wrong.
>>>>>>>>>>>> You rebuttal is based on rejecting the verified fact that a simulating
>>>>>>>>>>>> halt decider correctly predicts that its correctly simulated input will
>>>>>>>>>>>> never reach the final state "ret" instruction of this input.
>>>>>>>>>>>
>>>>>>>>>>> FALSE. The correctly simulated input to H(P,P) is UTM(P,P) which halts, therefore H(P,P)==0 is wrong.
>>>>>>>>>> First of all I am not talking about UTM's.
>>>>>>>>>> I am talking about x86 emulation.
>>>>>>>>>> Try to encode what you mean, here is my guess:
>>>>>>>>>>
>>>>>>>>>> void P(u32 x)
>>>>>>>>>> {
>>>>>>>>>> if (emulate_x86(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> P is a computation and therefore it can't be changed, nor can anything that it calls. I mean UTM(P,P). The simplest way to implement this is:
>>>>>>>>>
>>>>>>>>> void UTM(u32 x, u32 y)
>>>>>>>>> {
>>>>>>>>> x(y)
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> H cannot by definition perform a correct and complete emulation if it aborts, so the input must be passed to something that does, i.e. a UTM, for the source of truth.
>>>>>>>>>
>>>>>>>> A simulating halt decider correctly simulates its input until it
>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>> final state.
>>>>>>>
>>>>>>> But H isn't such a decider, because the simulated input does reach a final state when correctly simulated, i.e. by UTM(P,P), therefore H(P,P)==0 is wrong.
>>>>>>>
>>>>>> The semantics of the x86 language conclusively proves that H(P,P)
>>>>>> correctly determines/predicts that its complete and correct x86
>>>>>> emulation of its input would never reach the "ret" instruction of P.
>>>>>
>>>>> As previously stated, this is nonsense. Failure to explain *in detail* why the below is wrong will be taken as an admission that it is correct.
>>>>>
>>>>> It is known that H aborts its simulation and returns 0. That means that H *by definition* does not perform a complete and correct emulation. And since H (if it was constructed correctly) is a pure function of its inputs, it will ALWAYS return the same return for a given input.
>>>>>
>>>>> To state that H aborts *and* does a complete and correct simulation is simply nonsense.
>>>> I NEVER SAID that H does a complete and correct simulation of its input.
>>>
>>> Yes you did:
>>>
>>>> a) The complete and correct x86 emulation of the input to H(P,P) by H never reaches the "ret" instruction of P.
>>>
>> This does not say that H does a complete emulation.
>> A simulating halt decider correctly simulates its input until it
>> correctly determines that this simulated input would never reach its
>> final state.
>
> Which in the case of H(P,P) it doesn't since the correctly simulated input i.e. UTM(P,P) halts. H gets the wrong answer because it aborts too soon.
>
>> _Infinite_Loop()
>> [000015b8](01) 55 push ebp
>> [000015b9](02) 8bec mov ebp,esp
>> [000015bb](02) ebfe jmp 000015bb
>> [000015bd](01) 5d pop ebp
>> [000015be](01) c3 ret
>> Size in bytes:(0007) [000015be]
>>
>> The complete and correct x86 emulation of the input to H0(Infinite_Loop)
>> by H0 never reaches the "ret" instruction of Infinite_Loop.
>
> If H0 *actually* does a complete and correct emulation, then yes.

On 6/27/2022 2:19 PM, Mr Flibble wrote:
> On Mon, 27 Jun 2022 14:06:42 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/27/2022 1:53 PM, Mr Flibble wrote:
>>> On Mon, 27 Jun 2022 13:44:49 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/27/2022 1:20 PM, Mr Flibble wrote:
>>>>> On Mon, 27 Jun 2022 07:05:46 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> *This is the outline of the complete refutation*
>>>>>> *of the only rebuttal that anyone has left*
>>>>>>
>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P)
>>>>>> by H never reaches the "ret" instruction of P.
>>>>>>
>>>>>> (b) The direct execution of P(P) does reach its "ret"
>>>>>> instruction.
>>>>>>
>>>>>> The above two are proven to be verified facts entirely on the
>>>>>> basis of the semantics of the x86 language.
>>>>>>
>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>> accept or reject state on the basis of the actual behavior that
>>>>>> is actually specified by these inputs.
>>>>>>
>>>>>> P(P) is provably not the actual behavior of the actual input.
>>>>>>
>>>>>>
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> if (H(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [0000163a](01) 55 push ebp
>>>>>> [0000163b](02) 8bec mov ebp,esp
>>>>>> [0000163d](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001640](01) 50 push eax
>>>>>> [00001641](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001644](01) 51 push ecx
>>>>>> [00001645](05) e8f0fdffff call 0000143a // call H
>>>>>> [0000164a](03) 83c408 add esp,+08
>>>>>> [0000164d](02) 85c0 test eax,eax
>>>>>> [0000164f](02) 7402 jz 00001653
>>>>>> [00001651](02) ebfe jmp 00001651
>>>>>> [00001653](01) 5d pop ebp
>>>>>> [00001654](01) c3 ret
>>>>>> Size in bytes:(0027) [00001654]
>>>>>>
>>>>>> _main()
>>>>>> [0000165a](01) 55 push ebp
>>>>>> [0000165b](02) 8bec mov ebp,esp
>>>>>> [0000165d](05) 683a160000 push 0000163a // push P
>>>>>> [00001662](05) 683a160000 push 0000163a // push P
>>>>>> [00001667](05) e8cef9ffff call 0000103a // call H1
>>>>>> [0000166c](03) 83c408 add esp,+08
>>>>>> [0000166f](01) 50 push eax // push return
>>>>>> value [00001670](05) 689b040000 push 0000049b //
>>>>>> "Input_Halts = " [00001675](05) e870eeffff call 000004ea
>>>>>> // call Output [0000167a](03) 83c408 add esp,+08
>>>>>> [0000167d](02) 33c0 xor eax,eax
>>>>>> [0000167f](01) 5d pop ebp
>>>>>> [00001680](01) c3 ret
>>>>>> Size in bytes:(0039) [00001680]
>>>>>>
>>>>>> machine stack stack machine assembly
>>>>>> address address data code language
>>>>>> ======== ======== ======== ========= =============
>>>>>> [0000165a][001026a9][00000000] 55 push ebp
>>>>>> [0000165b][001026a9][00000000] 8bec mov ebp,esp
>>>>>> [0000165d][001026a5][0000163a] 683a160000 push 0000163a // push P
>>>>>> [00001662][001026a1][0000163a] 683a160000 push 0000163a // push P
>>>>>> [00001667][0010269d][0000166c] e8cef9ffff call 0000103a // call
>>>>>> H1
>>>>>>
>>>>>> H1: Begin Simulation Execution Trace Stored at:21275d
>>>>>> Address_of_H1:103a
>>>>>> [0000163a][00212749][0021274d] 55 push ebp
>>>>>> [0000163b][00212749][0021274d] 8bec mov ebp,esp
>>>>>> [0000163d][00212749][0021274d] 8b4508 mov eax,[ebp+08]
>>>>>> [00001640][00212745][0000163a] 50 push eax // push P
>>>>>> [00001641][00212745][0000163a] 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001644][00212741][0000163a] 51 push ecx // push P
>>>>>> [00001645][0021273d][0000164a] e8f0fdffff call 0000143a // call H
>>>>>>
>>>>>> H: Begin Simulation Execution Trace Stored at:2285c5
>>>>>> Address_of_H:143a
>>>>>> [0000163a][002285b1][002285b5] 55 push ebp
>>>>>> [0000163b][002285b1][002285b5] 8bec mov ebp,esp
>>>>>> [0000163d][002285b1][002285b5] 8b4508 mov eax,[ebp+08]
>>>>>> [00001640][002285ad][0000163a] 50 push eax // push P
>>>>>> [00001641][002285ad][0000163a] 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001644][002285a9][0000163a] 51 push ecx // push P
>>>>>> [00001645][002285a5][0000164a] e8f0fdffff call 0000143a // call H
>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>
>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>>>> [0000164d][00212749][0021274d] 85c0 test eax,eax
>>>>>> [0000164f][00212749][0021274d] 7402 jz 00001653
>>>>>> [00001653][0021274d][0000111e] 5d pop ebp
>>>>>> [00001654][00212751][0000163a] c3 ret
>>>>>> H1: End Simulation Input Terminated Normally
>>>>>>
>>>>>> [0000166c][001026a9][00000000] 83c408 add esp,+08
>>>>>> [0000166f][001026a5][00000001] 50 push eax // return
>>>>>> value [00001670][001026a1][0000049b] 689b040000 push 0000049b //
>>>>>> "Input_Halts = " [00001675][001026a1][0000049b] e870eeffff call
>>>>>> 000004ea // call Output Input_Halts = 1
>>>>>> [0000167a][001026a9][00000000] 83c408 add esp,+08
>>>>>> [0000167d][001026a9][00000000] 33c0 xor eax,eax
>>>>>> [0000167f][001026ad][00100000] 5d pop ebp
>>>>>> [00001680][001026b1][00000004] c3 ret
>>>>>> Number of Instructions Executed(409590) == 6113 Pages
>>>>>
>>>>> Why the new H/H1 dichotomy? Are you finally admitting that the
>>>>> decider that main() calls is different to the decider that P would
>>>>> call if you weren't erroneously aborting the simulation?
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The above example proves the following:
>>>>
>>>> (a) The complete and correct x86 emulation of the input to H(P,P)
>>>> by H never reaches the "ret" instruction of P.
>>>>
>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>
>>>
>>> Then H returned the wrong answer. See [Strachey, 1965].
>>>
>>> /Flibble
>>>
>>
>> So your rebuttals simply ignore that I proved you are wrong?
>>
>> // rec routine P
>> // §L :if T[P] go to L
>> // Return §
>> // https://academic.oup.com/comjnl/article/7/4/313/354243
>> void Strachey_P()
>> {
>> L:if (T(Strachey_P))
>> goto L;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", T(Strachey_P));
>> }
>>
>> _Strachey_P()
>> [000015b2](01) 55 push ebp
>> [000015b3](02) 8bec mov ebp,esp
>> [000015b5](05) 68b2150000 push 000015b2 // push Strachey_P
>> [000015ba](05) e813fdffff call 000012d2 // call T
>> [000015bf](03) 83c404 add esp,+04
>> [000015c2](02) 85c0 test eax,eax
>> [000015c4](02) 7402 jz 000015c8
>> [000015c6](02) ebed jmp 000015b5
>> [000015c8](01) 5d pop ebp
>> [000015c9](01) c3 ret
>> Size in bytes:(0024) [000015c9]
>>
>> _main()
>> [000015d2](01) 55 push ebp
>> [000015d3](02) 8bec mov ebp,esp
>> [000015d5](05) 68b2150000 push 000015b2 // push Strachey_P
>> [000015da](05) e8f3fcffff call 000012d2 // call T
>> [000015df](03) 83c404 add esp,+04
>> [000015e2](01) 50 push eax
>> [000015e3](05) 6833040000 push 00000433
>> [000015e8](05) e895eeffff call 00000482
>> [000015ed](03) 83c408 add esp,+08
>> [000015f0](02) 33c0 xor eax,eax
>> [000015f2](01) 5d pop ebp
>> [000015f3](01) c3 ret
>> Size in bytes:(0034) [000015f3]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [000015d2][001025c6][00000000] 55 push ebp
>> [000015d3][001025c6][00000000] 8bec mov ebp,esp
>> [000015d5][001025c2][000015b2] 68b2150000 push 000015b2 // push
>> Strachey_P [000015da][001025be][000015df] e8f3fcffff call 000012d2 //
>> call T
>>
>> Begin Simulation Execution Trace Stored at:21267a
>> Address_of_T:12d2
>> [000015b2][0021266a][0021266e] 55 push ebp
>> [000015b3][0021266a][0021266e] 8bec mov ebp,esp
>> [000015b5][00212666][000015b2] 68b2150000 push 000015b2 // push
>> Strachey_P [000015ba][00212662][000015bf] e813fdffff call 000012d2 //
>> call T Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> T knows its own machine address and on this basis it can easily
>> examine its stored execution_trace of Strachey_P (see above) to
>> determine: (a) Strachey_P is calling T with the same arguments that T
>> was called with. (b) No instructions in Strachey_P could possibly
>> escape this otherwise infinitely recursive emulation.
>> (c) T aborts its emulation of Strachey_P before its call to T is
>> emulated.
>>
>> [000015df][001025c6][00000000] 83c404 add esp,+04
>> [000015e2][001025c2][00000000] 50 push eax
>> [000015e3][001025be][00000433] 6833040000 push 00000433
>> [000015e8][001025be][00000433] e895eeffff call 00000482
>> Input_Halts = 0
>> [000015ed][001025c6][00000000] 83c408 add esp,+08
>> [000015f0][001025c6][00000000] 33c0 xor eax,eax
>> [000015f2][001025ca][00100000] 5d pop ebp
>> [000015f3][001025ce][00000004] c3 ret
>> Number of Instructions Executed(528) == 8 Pages
>
> There is no recursion in [Strachey, 1965]; a mistake you keep making
> again and again and again.
>
> /Flibble
>
>