Philosophy Now Forum

PeteOlcott wrote: ↑Fri May 13, 2022 6:10 am So you find an unconventional unpublished proof, that may or may not be correct, (no peer review).
None-The-Less I have defeated ALL the conventional proofs.

Skepdick wrote: ↑Fri May 13, 2022 6:29 am

PeteOlcott wrote: ↑Fri May 13, 2022 6:10 am So you find an unconventional unpublished proof, that may or may not be correct, (no peer review).
None-The-Less I have defeated ALL the conventional proofs.

This post on contains a link to a YouTube video. You really really should watch that video as an introduction to constructivism.

https://cs.stackexchange.com/questions/ ... lem-in-coq

In a nutshell you are doing proof by negation.

You produce H which negates P.
I produce P1 which negates H.
You produce H1 which negates P1.
I produce P2 which negates H1
...
Negation all the way down.

That's how falsification works in science.

You produce H which negates P.
I produce P1 which negates H.

PeteOlcott wrote: ↑Sat May 14, 2022 3:57 pm I abort P1 and report non-halting before P1 gets to its negation.
(my current proof)

Skepdick wrote: ↑Mon May 16, 2022 9:07 am

PeteOlcott wrote: ↑Sat May 14, 2022 3:57 pm I abort P1 and report non-halting before P1 gets to its negation.
(my current proof)

Oh, OK!

So I can do the exact same thing then?

I simulate H1 in P2.
I abort H1 before it gets to its negation of P1 halting.

If H1 proves that P1 doesn't halt, then P2 proves that H1 doesn't prove that P1 fails to halt.

Game theory 101 - strategy-stealing strategy.

PeteOlcott wrote: ↑Mon May 16, 2022 7:14 pm H(P,P)==0 and H1(P,P)==1 are provably correct

Skepdick wrote: ↑Mon May 16, 2022 7:20 pm

PeteOlcott wrote: ↑Mon May 16, 2022 7:14 pm H(P,P)==0 and H1(P,P)==1 are provably correct

P1(H(P,P)) == not(H(P,P)==0) is also provably correct.
P2(H1(P1, P1)) == not(H1(P1, P1) == 1) is also provably correct.

_P()
[000009d6](01) 55         push ebp
[000009d7](02) 8bec       mov ebp,esp
[000009d9](03) 8b4508     mov eax,[ebp+08]
[000009dc](01) 50         push eax         // push P
[000009dd](03) 8b4d08     mov ecx,[ebp+08]
[000009e0](01) 51         push ecx         // push P
[000009e1](05) e840feffff call 00000826    // call H
[000009e6](03) 83c408     add esp,+08
[000009e9](02) 85c0       test eax,eax
[000009eb](02) 7402       jz 000009ef
[000009ed](02) ebfe       jmp 000009ed
[000009ef](01) 5d         pop ebp
[000009f0](01) c3         ret              // Final state
Size in bytes:(0027) [000009f0]

PeteOlcott wrote: ↑Mon May 16, 2022 7:14 pm H(P,P)==0 and H1(P,P)==1 are provably correct

PeteOlcott wrote: ↑Mon May 16, 2022 7:31 pm There is no P1.

Skepdick wrote: ↑Mon May 16, 2022 7:31 pm

PeteOlcott wrote: ↑Mon May 16, 2022 7:14 pm H(P,P)==0 and H1(P,P)==1 are provably correct

But seriously. There's nothing to it. H(P,P)==0 is just a proposition valid. It doesn't mean anything until evaluated.

If H(P,P) returns 1 then the proposition is false.
If H(P,P) returns 0 then the proposition is true.

PeteOlcott wrote: ↑Mon May 16, 2022 7:53 pm That is a stupid thing to say everyone knows that 0 is false and non-zero is true in C.

H(P,P)==0 (meaning input is non-halting) and
H1(P,P)==1 (meaning input halts)

H(P,P) that correctly decides its input is fully operational code.

#include <stdio.h>
#include <assert.h>

int main()
{
    int x = 1;
    assert(x==1); //This assertion passes
    assert(x==0); //This assertion aborts the program
    return 0;
}

Skepdick wrote: ↑Mon May 16, 2022 7:58 pm

PeteOlcott wrote: ↑Mon May 16, 2022 7:53 pm That is a stupid thing to say everyone knows that 0 is false and non-zero is true in C.

H(P,P)==0 (meaning input is non-halting) and
H1(P,P)==1 (meaning input halts)

H(P,P) that correctly decides its input is fully operational code.

Are you stupid? == is a predicate. An assertion!

==(H(P,P), 0) returns True if H(P,P) is equal to 0.
==(H(P,P), 0) returns False if H(P,P) is equal to 0.
==(H(P,P), 1) returns True if H(P,P) is equal to 1.
==(H(P,P), 1) returns True if H(P,P) is equal to 0.

Code: Select all

#include <stdio.h>
#include <assert.h>

int main()
{
    int x = 1;
    assert(x==1); //This assertion passes
    assert(x==0); //This assertion aborts the program
    return 0;
}

PeteOlcott wrote: ↑Mon May 16, 2022 8:07 pm bool H(P,P) is defined to return 0 meaning that its input is non-halting.

PeteOlcott wrote: ↑Mon May 16, 2022 8:07 pm If you disagree with this you are a a liar.

#include <stdio.h>
#include <assert.h>

int main()
{
    0==1; 
    assert(1==0);
    return 0;
}

➜  ~ gcc main.c
main.c:6:6: warning: equality comparison result unused [-Wunused-comparison]
    0==1;
    ~^~~
1 warning generated.

➜  ~ ./a.out
Assertion failed: (1==0), function main, file main.c, line 7.
[1]    24650 abort      ./a.out

➜  ~ gcc -Werror main.c
main.c:6:6: error: equality comparison result unused [-Werror,-Wunused-comparison]
    0==1;
    ~^~~
1 error generated.

PeteOlcott wrote: ↑Mon May 16, 2022 8:25 pm H(P,P)==0 means that when H is applied to this fixed string of x86 machine code:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
H correctly determines that it never halts.

All the double talk strawman error cannot change this simple fact.

>>> type(0 == 1)
<class 'bool'>

Skepdick wrote: ↑Mon May 16, 2022 8:31 pm

PeteOlcott wrote: ↑Mon May 16, 2022 8:25 pm H(P,P)==0 means that when H is applied to this fixed string of x86 machine code:
558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
H correctly determines that it never halts.

All the double talk strawman error cannot change this simple fact.

Bullshit.

If H always halts (you claim it does) then H(P,P)==0 means either true; or false.