1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: H(D,D) cannot even be asked about the behavior of D(D) V2 ---ignori

    From Richard Damon@21:1/5 to olcott on Sat Jun 15 11:00:44 2024
    XPost: sci.logic

    On 6/15/24 10:37 AM, olcott wrote:
    On 6/13/2024 8:24 PM, Richard Damon wrote:
    On 6/13/24 11:32 AM, olcott wrote:

    It is contingent upon you to show the exact steps of how H computes
    the mapping from the x86 machine language finite string input to
    H(D,D) using the finite string transformation rules specified by
    the semantics of the x86 programming language that reaches the
    behavior of the directly executed D(D)


    Why? I don't claim it can.


    We must fully resolve this point before proceeding on any other
    halting problem points. If the reason that you don't answer is
    that this is simply over-your-head then it may not make sense to
    continue talking about these things with you.

    This is the key point that you must understand otherwise our
    conversation hit the brick wall of your persistently maintained
    ignorance.

    If there is no mapping from the input to H(D,D) to the behavior
    of D(D) then *H IS NOT BEING ASKED ABOUT THIS BEHAVIOR*



    You just seem to be stuck in your lies.

    There *IS* a mapping from the input to H(D,D) to the behavior of D(D),
    since we have that H(D,D) returns 0, so D(D) halts so the proper mapping
    of the input (D,D) is to 1.

    The fact that H didn't give that answer just makes it wrong, and if you
    change H, we need to start ALL OVER.

    So, since there IS a mapping from (D,D) -> 1 (for the D built on this H)
    it is totally proper to ask this H about this D,D

    I don't claim it is possible for this H to compute this mapping itself,
    and there is no requirement that it be able to.

    The proof shows that for ANY H that you might try to think up, there
    exist a specific input that this specific H will get wrong, and thus
    there can not exist an H that gets all input wrong, and thus there does
    not exist an algorithm to allow any decider to compute the mapping.

    That is perfectly fine, that just says that the Halting mapping is an uncomputable mapping, which is a perfectly valid result.

    Note, part of your problem is you express the question incorrectly,
    because you have a false idea of what is true.

    There is no requirement that H be able to "correctly simulate" its input
    to get the answer, and in fact, because we showed that Halting in non-computable, it means there is no "correct simulation" that the
    decider itself can do to get the answer.

    The other problem is how you try to express the input "D". By trying to
    exclude the code for H, you make D NOT a valid input to decide on, as we
    can only ask for the decision about a "computation", which means an
    algorithm (+input) that is ONLY dependent on that input, since the x86
    code for just the function D doesn't meet that requrement, it isn't a
    valid representation for the input of the program D. The program D FULLY INCLUDES all the code that it calls, and such includes the x86 code of
    H, and everything that H calls. If you can't treat that is part of "the
    input" then your decider just fails at the requirements stage.

    Once we include that copy of H, when you argue about changing H, you
    can't change the copy of H that D uses, and if that means you can't
    actualy change H, then you can't and you are arguing out of false
    assumptions.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jun 15 11:12:32 2024
    XPost: sci.logic

    On 6/15/24 11:07 AM, olcott wrote:
    On 6/15/2024 10:00 AM, Richard Damon wrote:
    On 6/15/24 10:37 AM, olcott wrote:
    On 6/13/2024 8:24 PM, Richard Damon wrote:
    On 6/13/24 11:32 AM, olcott wrote:

    It is contingent upon you to show the exact steps of how H computes
    the mapping from the x86 machine language finite string input to
    H(D,D) using the finite string transformation rules specified by
    the semantics of the x86 programming language that reaches the
    behavior of the directly executed D(D)


    Why? I don't claim it can.


    We must fully resolve this point before proceeding on any other
    halting problem points. If the reason that you don't answer is
    that this is simply over-your-head then it may not make sense to
    continue talking about these things with you.

    This is the key point that you must understand otherwise our
    conversation hit the brick wall of your persistently maintained
    ignorance.

    If there is no mapping from the input to H(D,D) to the behavior
    of D(D) then *H IS NOT BEING ASKED ABOUT THIS BEHAVIOR*



    You just seem to be stuck in your lies.

    There *IS* a mapping from the input to H(D,D) to the behavior of D(D),

    *Then do as I originally requested and provide ALL OF THE STEPS*
    *ANYTHING AND EVERYTHING BESIDES ALL OF THE STEPS WILL BE REJECTED* *OUT-OF-HAND AS WRONG ANSWER*

    Mappings don't HAVE steps.

    The mapping, for this H and D, is:

    (D,D) -> 1

    This is true, as it can be shown that D(D) will Halt, since H(D,D)
    returns 0. By definition, Halting Machines mean the mapping of the representations of that machine are to Halting (which is represented by
    1 for your decider).

    You are just showing a total ignorance of the topic.


    _D()
    [00000cfc](01) 55          push ebp
    [00000cfd](02) 8bec        mov ebp,esp
    [00000cff](03) 8b4508      mov eax,[ebp+08]
    [00000d02](01) 50          push eax       ; push D [00000d03](03) 8b4d08      mov ecx,[ebp+08]
    [00000d06](01) 51          push ecx       ; push D [00000d07](05) e800feffff  call 00000b0c  ; call H
    [00000d0c](03) 83c408      add esp,+08
    [00000d0f](02) 85c0        test eax,eax
    [00000d11](02) 7404        jz 00000d17
    [00000d13](02) 33c0        xor eax,eax
    [00000d15](02) eb05        jmp 00000d1c
    [00000d17](05) b801000000  mov eax,00000001
    [00000d1c](01) 5d          pop ebp
    [00000d1d](01) c3          ret
    Size in bytes:(0034) [00000d1d]



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Sat Jun 15 16:11:20 2024
    XPost: sci.logic

    Am Sat, 15 Jun 2024 10:54:54 -0500 schrieb olcott:
    On 6/15/2024 10:12 AM, Richard Damon wrote:
    On 6/15/24 11:07 AM, olcott wrote:
    On 6/15/2024 10:00 AM, Richard Damon wrote:
    On 6/15/24 10:37 AM, olcott wrote:
    On 6/13/2024 8:24 PM, Richard Damon wrote:
    On 6/13/24 11:32 AM, olcott wrote:

    *Then do as I originally requested and provide ALL OF THE STEPS*
    The mapping, for this H and D, is:
    (D,D) -> 1
    I am asking for a mapping from the machine language finite string of the input to H(D,D) to each of the individual steps of the behavior of D(D).
    D calls H, which by definition terminates. From its return value we fork
    to either enter an endless loop or halt. Then H (which is not allowed to simulate D if that doesn't halt) gives the result we just used to fork.

    --
    joes

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jun 15 12:12:46 2024
    XPost: sci.logic

    On 6/15/24 11:54 AM, olcott wrote:
    On 6/15/2024 10:12 AM, Richard Damon wrote:
    On 6/15/24 11:07 AM, olcott wrote:
    On 6/15/2024 10:00 AM, Richard Damon wrote:
    On 6/15/24 10:37 AM, olcott wrote:
    On 6/13/2024 8:24 PM, Richard Damon wrote:
    On 6/13/24 11:32 AM, olcott wrote:

    It is contingent upon you to show the exact steps of how H computes >>>>>>> the mapping from the x86 machine language finite string input to >>>>>>> H(D,D) using the finite string transformation rules specified by >>>>>>> the semantics of the x86 programming language that reaches the
    behavior of the directly executed D(D)


    Why? I don't claim it can.


    We must fully resolve this point before proceeding on any other
    halting problem points. If the reason that you don't answer is
    that this is simply over-your-head then it may not make sense to
    continue talking about these things with you.

    This is the key point that you must understand otherwise our
    conversation hit the brick wall of your persistently maintained
    ignorance.

    If there is no mapping from the input to H(D,D) to the behavior
    of D(D) then *H IS NOT BEING ASKED ABOUT THIS BEHAVIOR*



    You just seem to be stuck in your lies.

    There *IS* a mapping from the input to H(D,D) to the behavior of D(D),

    *Then do as I originally requested and provide ALL OF THE STEPS*
    *ANYTHING AND EVERYTHING BESIDES ALL OF THE STEPS WILL BE REJECTED*
    *OUT-OF-HAND AS WRONG ANSWER*

    Mappings don't HAVE steps.

    The mapping, for this H and D, is:

    (D,D) -> 1


    *Wrong mapping*
    I am not asking for a mapping from the input to H(D,D)
    to a possible output from H(D,D).

    So, are you admitting you are just giving up? Or you don't want shown
    the answer that proves you wrong?


    I am asking for a mapping from the machine language finite
    string of the input to H(D,D) to each of the individual steps
    of the behavior of D(D).

    Why?

    That isn't the "mapping" that defines what H is supposed to answer with,
    and isn't what would normally be called a "mapping" at all.

    That would just be the steps of simulaton.

    I guess you are just trying again to be deceitful by changing your
    definitions, just showing how your "native tounge" is lies.


    The first six steps of the mapping from the input to H(D,D)
    and the behavior of D(D) are the execution/simulation of
    the machine code at address range [00000cfc] to [00000d06].

    So? And to be a "correct simulation" by your definitions, it must then
    simulate the Call H instruction, and then the instructions of H never to
    retutn to D again, unless it reaches the point where H return the value
    0, which appears to be impossible to get to.


    _D()
    [00000cfc](01) 55          push ebp
    [00000cfd](02) 8bec        mov ebp,esp
    [00000cff](03) 8b4508      mov eax,[ebp+08]
    [00000d02](01) 50          push eax       ; push D [00000d03](03) 8b4d08      mov ecx,[ebp+08]
    [00000d06](01) 51          push ecx       ; push D [00000d07](05) e800feffff  call 00000b0c  ; call H
    [00000d0c](03) 83c408      add esp,+08
    [00000d0f](02) 85c0        test eax,eax
    [00000d11](02) 7404        jz 00000d17
    [00000d13](02) 33c0        xor eax,eax
    [00000d15](02) eb05        jmp 00000d1c
    [00000d17](05) b801000000  mov eax,00000001
    [00000d1c](01) 5d          pop ebp
    [00000d1d](01) c3          ret
    Size in bytes:(0034) [00000d1d]



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jun 15 12:26:37 2024
    XPost: sci.logic

    On 6/15/24 12:19 PM, olcott wrote:
    On 6/15/2024 11:11 AM, joes wrote:
    Am Sat, 15 Jun 2024 10:54:54 -0500 schrieb olcott:
    On 6/15/2024 10:12 AM, Richard Damon wrote:
    On 6/15/24 11:07 AM, olcott wrote:
    On 6/15/2024 10:00 AM, Richard Damon wrote:
    On 6/15/24 10:37 AM, olcott wrote:
    On 6/13/2024 8:24 PM, Richard Damon wrote:
    On 6/13/24 11:32 AM, olcott wrote:

    *Then do as I originally requested and provide ALL OF THE STEPS*
    The mapping, for this H and D, is:
    (D,D) -> 1
    I am asking for a mapping from the machine language finite string of the >>> input to H(D,D) to each of the individual steps of the behavior of D(D).

    *THIS SEEMS WAY WAY OVER YOUR HEAD*
    It is contingent upon you to show the exact steps of how H computes
    the mapping from the x86 machine language finite string input to
    H(D,D) using the finite string transformation rules specified by
    the semantics of the x86 programming language that reaches the
    behavior of the directly executed D(D)

    Why is that contingent on anyone but the programmer who claims to be
    able to write such a decider?


    The first six steps of this mapping are when instructions
    at the machine address range of [00000cfc] to [00000d06]
    are simulated/executed.

    After that the behavior of D correctly simulated by H diverges
    from the behavior of D(D) because the call to H(D,D) by D
    correctly simulated by H cannot possibly return to D.

    Which just shows that H can not actually correctly simulate all of the
    behavior of the input, but it always gives up and just guesses at an
    answer, which is wrong.


    _D()
    [00000cfc](01) 55          push ebp
    [00000cfd](02) 8bec        mov ebp,esp
    [00000cff](03) 8b4508      mov eax,[ebp+08]
    [00000d02](01) 50          push eax       ; push D [00000d03](03) 8b4d08      mov ecx,[ebp+08]
    [00000d06](01) 51          push ecx       ; push D [00000d07](05) e800feffff  call 00000b0c  ; call H
    [00000d0c](03) 83c408      add esp,+08
    [00000d0f](02) 85c0        test eax,eax
    [00000d11](02) 7404        jz 00000d17
    [00000d13](02) 33c0        xor eax,eax
    [00000d15](02) eb05        jmp 00000d1c
    [00000d17](05) b801000000  mov eax,00000001
    [00000d1c](01) 5d          pop ebp
    [00000d1d](01) c3          ret
    Size in bytes:(0034) [00000d1d]



    D calls H, which by definition terminates. From its return value we fork
    to either enter an endless loop or halt. Then H (which is not allowed to
    simulate D if that doesn't halt) gives the result we just used to fork.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jun 15 12:41:37 2024
    XPost: sci.logic

    On 6/15/24 12:31 PM, olcott wrote:
    On 6/15/2024 11:26 AM, Richard Damon wrote:
    On 6/15/24 12:19 PM, olcott wrote:
    On 6/15/2024 11:11 AM, joes wrote:
    Am Sat, 15 Jun 2024 10:54:54 -0500 schrieb olcott:
    On 6/15/2024 10:12 AM, Richard Damon wrote:
    On 6/15/24 11:07 AM, olcott wrote:
    On 6/15/2024 10:00 AM, Richard Damon wrote:
    On 6/15/24 10:37 AM, olcott wrote:
    On 6/13/2024 8:24 PM, Richard Damon wrote:
    On 6/13/24 11:32 AM, olcott wrote:

    *Then do as I originally requested and provide ALL OF THE STEPS*
    The mapping, for this H and D, is:
    (D,D) -> 1
    I am asking for a mapping from the machine language finite string
    of the
    input to H(D,D) to each of the individual steps of the behavior of
    D(D).

    *THIS SEEMS WAY WAY OVER YOUR HEAD*
    It is contingent upon you to show the exact steps of how H computes
    the mapping from the x86 machine language finite string input to
    H(D,D) using the finite string transformation rules specified by
    the semantics of the x86 programming language that reaches the
    behavior of the directly executed D(D)

    Why is that contingent on anyone but the programmer who claims to be
    able to write such a decider?


    The first six steps of this mapping are when instructions
    at the machine address range of [00000cfc] to [00000d06]
    are simulated/executed.

    After that the behavior of D correctly simulated by H diverges
    from the behavior of D(D) because the call to H(D,D) by D
    correctly simulated by H cannot possibly return to D.

    Which just shows that H can not actually correctly simulate all of the
    behavior of the input, but it always gives up and just guesses at an
    answer, which is wrong.


    _D()
    [00000cfc](01) 55          push ebp
    [00000cfd](02) 8bec        mov ebp,esp
    [00000cff](03) 8b4508      mov eax,[ebp+08]
    [00000d02](01) 50          push eax       ; push D
    [00000d03](03) 8b4d08      mov ecx,[ebp+08]
    [00000d06](01) 51          push ecx       ; push D
    [00000d07](05) e800feffff  call 00000b0c  ; call H
    [00000d0c](03) 83c408      add esp,+08
    [00000d0f](02) 85c0        test eax,eax
    [00000d11](02) 7404        jz 00000d17
    [00000d13](02) 33c0        xor eax,eax
    [00000d15](02) eb05        jmp 00000d1c
    [00000d17](05) b801000000  mov eax,00000001
    [00000d1c](01) 5d          pop ebp
    [00000d1d](01) c3          ret
    Size in bytes:(0034) [00000d1d]



    D calls H, which by definition terminates. From its return value we
    fork
    to either enter an endless loop or halt. Then H (which is not
    allowed to
    simulate D if that doesn't halt) gives the result we just used to fork. >>>>



    ONLY addressing V3

    Which is why you will never be able to publsih, because they won't let
    you do that.

    You STILL are fundamentally ignoring the basic definitions of the
    system, and thus are just LYING about what you are doing.

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