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.

--
Copyright 2022 Pete Olcott

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