XPost: comp.theory, sci.logic, sci.math
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.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)