On 6/8/22 8:35 AM, olcott wrote:
> On 6/8/2022 5:57 AM, Richard Damon wrote:
>> On 6/7/22 11:59 PM, olcott wrote:
>>> On 6/7/2022 10:54 PM, Richard Damon wrote:
>>>> On 6/7/22 11:43 PM, olcott wrote:
>>>>> On 6/7/2022 10:25 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 6/7/22 11:17 PM, olcott wrote:
>>>>>>> On 6/7/2022 9:50 PM, Richard Damon wrote:
>>>>>>>> On 6/7/22 10:25 PM, olcott wrote:
>>>>>>>>> On 6/7/2022 8:05 PM, Richard Damon wrote:
>>>>>>>>>> On 6/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>> On 6/7/2022 7:42 PM, Mr Flibble wrote:
>>>>>>>>>>>> Hi,
>>>>>>>>>>>>
>>>>>>>>>>>>  From discussion with Olcott in comp.lang.c++ I have
>>>>>>>>>>>> determined that
>>>>>>>>>>>> his so called refutation of the HP proofs is based around the
>>>>>>>>>>>> behaviour of his simulation-based decider, H:
>>>>>>>>>>>>
>>>>>>>>>>>> void Q(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>>           if (H(x, x))
>>>>>>>>>>>>             FUBAR();
>>>>>>>>>>>>           return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>           Output("Input_Halts = ", H((u32)Q, (u32)Q));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> He asserts H(Q,Q)=0 based on a nested simulation being
>>>>>>>>>>>> detected (i.e. Q
>>>>>>>>>>>> invoking H) irregardless of whether FUBAR halts or not.
>>>>>>>>>>>>
>>>>>>>>>>>> If FUBAR halts H gives the wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> He claims H(Q,Q)=0 as it gets stuck in a recursive (nested)
>>>>>>>>>>>> simulation
>>>>>>>>>>>> however that wouldn't be the case for non-simulating decider
>>>>>>>>>>>> for which
>>>>>>>>>>>> there would be no such recursion.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I propose a way to correctly decide the impossible input and
>>>>>>>>>>> your "rebuttal" is that there are still other wrong ways to
>>>>>>>>>>> do this that don't work.
>>>>>>>>>>
>>>>>>>>>> Nope, you propose that if you can make a machine that both
>>>>>>>>>> RUNS FOREVER and also STOPS PART WAY at the same time with the
>>>>>>>>>> same input, that you can solve the problem.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> RICHARD ACTS AS IF HE IS TOO STUPID TO KNOW THAT A PARTIAL
>>>>>>>>> SIMULATION OF AN INPUT DOES CORRECTLY PREDICT THAT A COMPLETE
>>>>>>>>> SIMULATION WOULD NEVER HALT.
>>>>>>>>
>>>>>>>> No, Peter Olcott shows he is too stupid to understand the
>>>>>>>> fallacy of Proof by Example.
>>>>>>>>
>>>>>>>
>>>>>>> You are too stupid to know that this does not apply.
>>>>>>> When one is 100% specific there is no generalization at all thus
>>>>>>> making inappropriate generalization impossible.
>>>>>>>
>>>>>>> In logic and mathematics, proof by example (sometimes known as
>>>>>>> inappropriate generalization)
>>>>>>> https://en.wikipedia.org/wiki/Proof_by_example
>>>>>>>
>>>>>>
>>>>>> Right, and showing that an algorith works to detect
>>>>>
>>>>> A single 100% specific instance of infinitely nested simulation is
>>>>> not any freaking generalization at all. You actually might be
>>>>> stupid in which case I take it back. It is rude to call stupid
>>>>> people stupid because it is not their fault. I called you stupid
>>>>> because I thought you were playing sadistic head games.
>>>>>
>>>>>
>>>>
>>>> WHAT 100% specific instanc of infintely nested simualtions.
>>>>
>>>
>>> #include <stdint.h>
>>> #define u32 uint32_t
>>>
>>> void P(u32 x)
>>> {
>>>    if (H(x, x))
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>> _P()
>>> [00001352](01)  55              push ebp
>>> [00001353](02)  8bec            mov ebp,esp
>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>> [00001358](01)  50              push eax      // push P
>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>> [0000135c](01)  51              push ecx      // push P
>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>> [00001362](03)  83c408          add esp,+08
>>> [00001365](02)  85c0            test eax,eax
>>> [00001367](02)  7402            jz 0000136b
>>> [00001369](02)  ebfe            jmp 00001369
>>> [0000136b](01)  5d              pop ebp
>>> [0000136c](01)  c3              ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> _main()
>>> [00001372](01)  55              push ebp
>>> [00001373](02)  8bec            mov ebp,esp
>>> [00001375](05)  6852130000      push 00001352 // push P
>>> [0000137a](05)  6852130000      push 00001352 // push P
>>> [0000137f](05)  e81efeffff      call 000011a2 // call H
>>> [00001384](03)  83c408          add esp,+08
>>> [00001387](01)  50              push eax
>>> [00001388](05)  6823040000      push 00000423 // "Input_Halts = "
>>> [0000138d](05)  e8e0f0ffff      call 00000472 // call Output
>>> [00001392](03)  83c408          add esp,+08
>>> [00001395](02)  33c0            xor eax,eax
>>> [00001397](01)  5d              pop ebp
>>> [00001398](01)  c3              ret
>>> Size in bytes:(0039) [00001398]
>>>
>>>      machine   stack     stack     machine    assembly
>>>      address   address   data      code       language
>>>      ========  ========  ========  =========  =============
>>> ...[00001372][0010229e][00000000] 55         push ebp
>>> ...[00001373][0010229e][00000000] 8bec       mov ebp,esp
>>> ...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
>>> ...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
>>> ...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H
>>>
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
>>>
>>> // H emulates the first seven instructions of P
>>> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>> ...[00001358][0021233a][00001352] 50         push eax      // push P
>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>> ...[0000135c][00212336][00001352] 51         push ecx      // push P
>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>>>
>>> // The emulated H emulates the first seven instructions of P
>>> ...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
>>> ...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
>>> ...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
>>> ...[00001358][0025cd62][00001352] 50         push eax      // push P
>>> ...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
>>> ...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> It is completely obvious that when H(P,P) correctly emulates its
>>> input that it must emulate the first seven instructions of P. Because
>>> the seventh instruction of P repeats this process we can know with
>>> complete certainty that the emulated P never reaches its final “ret”
>>> instruction, thus never halts.
>>>
>>> ...[00001384][0010229e][00000000] 83c408     add esp,+08
>>> ...[00001387][0010229a][00000000] 50         push eax
>>> ...[00001388][00102296][00000423] 6823040000 push 00000423 //
>>> "Input_Halts = "
>>> ---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call
>>> Output
>>> Input_Halts = 0
>>> ...[00001392][0010229e][00000000] 83c408     add esp,+08
>>> ...[00001395][0010229e][00000000] 33c0       xor eax,eax
>>> ...[00001397][001022a2][00100000] 5d         pop ebp
>>> ...[00001398][001022a6][00000004] c3         ret
>>> Number of Instructions Executed(15892) = 237 pages
>>>
>>>
>>
>> Except that H is wrong, because it didn't actually emulate the input
>> correctly.
>
> H(P,P) correctly emulates 14 steps of its input providing H the
> sufficient basis to determine that a complete emulation of its input
> never reaches the "ret" instruction of this input.
>
>

No, it doesn't as the 8th step of its input is the first instruction of
the copy of H used by P.

That is what the meaning of correct x86 emulation would mean, as that is
what the x86 processor would do.

Please show me an x86 processor manual that states otherwise.

Otherwise, you are just shown to lie.