• Re: Proof that H(P,P)==0 is correct [ foundation of truth itself ]

    From olcott@21:1/5 to Ben on Fri May 13 12:01:29 2022
    XPost: comp.theory, sci.logic, sci.lang.semantics

    On 5/13/2022 6:05 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    All of my studies of Gödel 1931, Tarski 1936, the HP and the Liar
    Paradox have been concrete proxies for my study of the philosophical
    foundation of analytical truth.

    Why have you not had anything published? Everyone here knows why, but
    what's your opinion?


    I have to conclusively prove my point concretely such the every single
    detail of my reasoning can be verified as factually correct before
    people will understand that I have corrected errors in some of the
    aspects of the basic foundations of logic.

    Actual fully operational code refuting the HP proof works best for this
    because the Gödel, Tarski, and the LP have hidden semantic gaps that are defined as non-existent by the conventional terms of their art so they
    cannot be seen when using these terms of the art.

    The errors in the foundations of logic can be summed up very simply.
    Whenever only truth preserving operations are applied to expressions of language known to be true then a true conclusion is derived.

    I also correct the definition of validity:

    Validity and Soundness
    A deductive argument is said to be valid if and only if it takes a form
    that makes it impossible for the premises to be true and the conclusion nevertheless to be false. Otherwise, a deductive argument is said to be invalid. https://iep.utm.edu/val-snd/

    If the Moon is made of green cheese then all dogs are cats is valid and
    even though premises and conclusion are semantically unrelated.

    Here is my correction to that issue:
    A deductive argument is said to be valid if and only if it takes a form
    that its conclusion is a necessary consequence of all of its premises.

    The semantically unrelated premises and conclusion is not possible with syllogisms. https://en.wikipedia.org/wiki/Syllogism#Basic_structure

    Because syllogisms are comprised of https://en.wikipedia.org/wiki/Categorical_proposition

    You can't publish H(P,P) == false even though P(P) halts, but I leave
    the rest of you grand claims to others.



    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Dennis Bush on Fri May 13 15:38:23 2022
    XPost: comp.theory, sci.logic

    On 5/13/2022 3:26 PM, Dennis Bush wrote:
    On Friday, May 13, 2022 at 4:22:17 PM UTC-4, olcott wrote:
    On 5/13/2022 3:11 PM, Richard Damon wrote:
    On 5/13/22 3:24 PM, olcott wrote:
    On 5/13/2022 2:06 PM, Ben wrote:
    olcott <No...@NoWhere.com> writes:

    On 5/13/2022 6:05 AM, Ben wrote:
    olcott <No...@NoWhere.com> writes:

    All of my studies of Gödel 1931, Tarski 1936, the HP and the Liar >>>>>>>> Paradox have been concrete proxies for my study of the philosophical >>>>>>>> foundation of analytical truth.

    Why have you not had anything published? Everyone here knows why, but >>>>>>> what's your opinion?

    I have to conclusively prove my point concretely such the every single >>>>>> detail of my reasoning can be verified as factually correct before >>>>>> people will understand that I have corrected errors in some of the >>>>>> aspects of the basic foundations of logic.

    Hmm.. but it's "dead obvious", isn't it?


    It has been dead obvious that H(P,P)==0 is the correct halt status for >>>> the input to H(P,P) on the basis of the actual behavior that this
    input actually specifies.

    This has been dead obvious on this basis for at least six months, yet
    people very persistently insisted on simply ignoring the easily
    verifiable facts for this whole six month period.


    Nope, since BY THE PROBLEM STATEMENT of the Halting Problem, the "actual >>> behavior" of the input to H applied to <H^> <H^> is DEFINED to be the
    behavior of H^ applied to <H^>.

    The ultimate measure superseding and overruling every other measure is
    the actual behavior of the actual input as demonstrated by a correct
    simulation of this input by the simulating halt decider.

    And your H doesn't perform a correct simulation as has been described many times.

    That the execution trace provided by H(P,P) exactly matches the behavior
    that the x86 source-code of P specifies conclusively proves that the
    simulation of the input to H(P,P) is correct.

    How much longer are you going to deny this empirically proven fact?
    How much longer are you going to deny this empirically proven fact?
    How much longer are you going to deny this empirically proven fact?
    How much longer are you going to deny this empirically proven fact?
    How much longer are you going to deny this empirically proven fact?

    #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
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx
    [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 ...[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 ...[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

    H sees that P is calling the same function from the same machine address
    with identical parameters, twice in sequence. This is the infinite
    recursion (infinitely nested simulation) non-halting behavior pattern.

    ...[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_User_Instructions(1)
    Number of Instructions Executed(15892)


    --
    Copyright 2022 Pete Olcott

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mr Flibble@21:1/5 to olcott on Fri May 13 21:44:07 2022
    XPost: comp.theory, sci.logic

    On Fri, 13 May 2022 15:38:23 -0500
    olcott <NoOne@NoWhere.com> wrote:
    H sees that P is calling the same function from the same machine
    address with identical parameters, twice in sequence. This is the
    infinite recursion (infinitely nested simulation) non-halting
    behavior pattern.

    An infinite recursion that only exists in your simulation and not in
    the proofs you are attempting to refute. Your simulation is based on a
    category error and is thus invalid.

    Give it up and do something useful with the rest of your life.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)