1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: DDD correctly emulated by HHH --- Correct Emulation Defined

    From Mr Flibble@21:1/5 to olcott on Thu Mar 20 02:51:42 2025
    On Wed, 19 Mar 2025 21:32:43 -0500, olcott wrote:

    DDD()
    [00002172] 55 push ebp ; housekeeping [00002173] 8bec
    mov ebp,esp ; housekeeping [00002175] 6872210000 push 00002172 ; push
    DDD [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404 add esp,+04 [00002182] 5d pop ebp
    [00002183] c3 ret Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according to the semantics of
    the x86 language then these N steps are emulated correctly.

    Get another fucking hobby, ffs.

    /Flibble

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Thu Mar 20 11:16:49 2025
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55 push ebp ; housekeeping
    [00002173] 8bec mov ebp,esp ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404 add esp,+04
    [00002182] 5d pop ebp
    [00002183] c3 ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as
    it should mean whatever "correct emulation" means when applied to DDD.

    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.

    The term should be or include "partial emulation" when the intent is
    that an emulation that could be continued is not is called "correct".

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Mar 20 07:00:23 2025
    On 3/19/25 10:32 PM, olcott wrote:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.


    Right, The N Steps of DDD were emulated correctly, but not the WHOLE of
    DDD, that wasn't correctly emulated.

    Again, you confuse two different things and call them the same.

    By your logic, if you get off a highway at the first exit, and thus can
    say for certain that it didn't end in that first streach, that the full
    road which continued on from there, must never end anywhere.


    Sorry, you are just proving you know you are committing FRAUD by lying
    about your definitions.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Mar 20 21:31:05 2025
    On 3/20/25 6:43 PM, olcott wrote:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as
    it should mean whatever "correct emulation" means when applied to DDD.

    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.


    N in this context always means any element of the
    set of natural numbers.

    Then HHH isn't a specific program, and you are admitting that you
    "logic" is just based on FRAUD.


    1,2,3...4,294,967,296 steps of DDD are correctly emulated
    by HHH and DDD never reaches its "ret" instruction and
    terminates normally.

    DIFFERENT HHHs and thus DIFFERENT DDDs were emulated.


    The term should be or include "partial emulation" when the intent is
    that an emulation that could be continued is not is called "correct".


    A finite number of N steps means a finite emulation.


    Right, and every one of them creates an input DDD, that when COMPLETELY emulated halts, and thus should be called a halting input in any HONEST
    logic system.

    Of course, in your FRAUD, you claim otherwise, but that just shows how
    bad your FRAUDULANT system is,

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri Mar 21 10:01:39 2025
    On 2025-03-21 01:48:22 +0000, olcott said:

    On 3/20/2025 8:31 PM, Richard Damon wrote:
    On 3/20/25 6:43 PM, olcott wrote:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as >>>> it should mean whatever "correct emulation" means when applied to DDD. >>>>
    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.


    N in this context always means any element of the
    set of natural numbers.

    Then HHH isn't a specific program, and you are admitting that you
    "logic" is just based on FRAUD.


    We have been over this same thing too many times.

    You are right. But you can't figure out how to avoid that.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri Mar 21 09:59:34 2025
    On 2025-03-20 22:43:34 +0000, olcott said:

    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as
    it should mean whatever "correct emulation" means when applied to DDD.

    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.

    N in this context always means any element of the
    set of natural numbers.

    No, it does not. It means a number that makes sense in the context and
    will be specified when the definition shall be applied.

    1,2,3...4,294,967,296 steps of DDD are correctly emulated
    by HHH and DDD never reaches its "ret" instruction and
    terminates normally.

    But your HHH does not simulate correctly more steps of DDD than your
    HHH1 does.

    The term should be or include "partial emulation" when the intent is
    that an emulation that could be continued is not is called "correct".

    A finite number of N steps means a finite emulation.

    Irrelevant as that phrase was not used.

    And all of the above is irrelevant to the fact "correct emulation" was
    not defined, contrary to the promise on the subject line.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri Mar 21 07:48:32 2025
    On 3/20/25 9:48 PM, olcott wrote:
    On 3/20/2025 8:31 PM, Richard Damon wrote:
    On 3/20/25 6:43 PM, olcott wrote:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as >>>> it should mean whatever "correct emulation" means when applied to DDD. >>>>
    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.


    N in this context always means any element of the
    set of natural numbers.

    Then HHH isn't a specific program, and you are admitting that you
    "logic" is just based on FRAUD.


    We have been over this same thing too many times.

    Right, and you still don't understand that you are required to follow
    the definitions of the system to be in the system.

    You have ADMITTED that you aren't following the rules of the system, and
    thus every time you imply that you are, you have admitted you are lying.

    Thus, every time you claim to be "solving" the Halting Problem, you have admitted you are just lying about that.



    1,2,3...4,294,967,296 steps of DDD are correctly emulated
    by HHH and DDD never reaches its "ret" instruction and
    terminates normally.

    DIFFERENT HHHs and thus DIFFERENT DDDs were emulated.


    The point remains the same without the additional details.
    For every HHH at machine address 000015d2 when the above
    listed machine code is emulated for any finite number of
    steps according to the semantics of the x86 language the
    above finite string of machine code never reaches its own
    "ret" instruction and halts.

    In other words, you claim it is ok to lie about the system you are
    working on.

    The "additional details" are just the facts that you want to ignore.

    Sorry, you are just showing that you whole world is built on FRAUD and LIES.

    Your words mean nothing, as you have admitted that you change the
    meaning of them, yet haven't actually defined your meaning, as to do so
    makes it clear that you have been lying about working on the problems.



    The term should be or include "partial emulation" when the intent is
    that an emulation that could be continued is not is called "correct".


    A finite number of N steps means a finite emulation.


    Right, and every one of them creates an input DDD,

    Same finite string at the same machine address 00002172.

    But of something that isn't a program, and thus a type error.

    Your logic vacillates between the string being that short string of just
    the function, or actually being all of memory.


    that when COMPLETELY emulated halts,

    You already said that DDD emulated by HHH never reaches
    its own "ret" instruction in any finite number of steps,
    WHY LIE ABOUT THIS NOW?

    Because they are different FACTS.

    An HHH that does just a partial emulation, doesn't do a CORRECT
    emulation, and thus any conclusion based on the assumption that it did
    one is invalid.

    You don't seem to understand that real logic needs to work from truthful premises.


    and thus should be called a halting input in any HONEST logic system.

    WHY LIE ABOUT THIS NOW?

    Yes, why do you lie?

    Try to show where I lied under the actual definition of the system you
    are actually stuck in to be able to talk about the proofs (and not your
    system based on FRAUD).


    Of course, in your FRAUD, you claim otherwise, but that just shows how
    bad your FRAUDULANT system is,



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Fri Mar 21 17:56:56 2025
    Am Fri, 21 Mar 2025 08:07:38 -0500 schrieb olcott:
    On 3/21/2025 2:59 AM, Mikko wrote:
    On 2025-03-20 22:43:34 +0000, olcott said:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    When N steps of DDD are emulated by HHH according to the semantics
    of the x86 language then these N steps are emulated correctly.
    That does not make much sense to define the correct emulation of DDD
    as it should mean whatever "correct emulation" means when applied to
    DDD.
    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.
    N in this context always means any element of the set of natural
    numbers.
    No, it does not. It means a number that makes sense in the context and
    will be specified when the definition shall be applied.


    1,2,3...4,294,967,296 steps of DDD are correctly emulated by HHH and
    DDD never reaches its "ret" instruction and terminates normally.

    But your HHH does not simulate correctly more steps of DDD than your
    HHH1 does.

    This HHH is the hypothetical HHH the emulates an arbitrary number of
    steps of DDD according to the semantics of the x86 language.
    No, your HHH is real and it does not simulate arbitrarily many
    instructions.

    It is always at machine address 000015d2. This same HHH also has the
    ability to emulate itself emulating DDD.
    No, it can't simulate itself to its definite termination.

    --
    Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
    It is not guaranteed that n+1 exists for every n.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Fri Mar 21 23:46:48 2025
    Am Fri, 21 Mar 2025 13:58:02 -0500 schrieb olcott:
    On 3/21/2025 12:56 PM, joes wrote:
    Am Fri, 21 Mar 2025 08:07:38 -0500 schrieb olcott:
    On 3/21/2025 2:59 AM, Mikko wrote:
    On 2025-03-20 22:43:34 +0000, olcott said:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    1,2,3...4,294,967,296 steps of DDD are correctly emulated by HHH and >>>>> DDD never reaches its "ret" instruction and terminates normally.
    But your HHH does not simulate correctly more steps of DDD than your
    HHH1 does.
    This HHH is the hypothetical HHH the emulates an arbitrary number of
    steps of DDD according to the semantics of the x86 language.
    No, your HHH is real and it does not simulate arbitrarily many
    instructions.
    If DDD behaves the same way for every possible HHH then it behaves this
    way for any particular HHH.
    Yes, all of them simulate only partially.

    It is always at machine address 000015d2. This same HHH also has the
    ability to emulate itself emulating DDD.
    No, it can't simulate itself to its definite termination.
    HHH does simulate itself simulating DDD to the final state of HHH.
    If it did that, the simulated HHH would return and DD would halt
    instead of getting aborted.

    --
    Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
    It is not guaranteed that n+1 exists for every n.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri Mar 21 19:49:14 2025
    On 3/21/25 9:10 AM, olcott wrote:
    On 3/21/2025 3:01 AM, Mikko wrote:
    On 2025-03-21 01:48:22 +0000, olcott said:

    On 3/20/2025 8:31 PM, Richard Damon wrote:
    On 3/20/25 6:43 PM, olcott wrote:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of
    DDD as
    it should mean whatever "correct emulation" means when applied to
    DDD.

    Althouth promised otherwise on the subject line the meaning of "DDD >>>>>> correctly emulated by HHH" when N is not specified is not defined. >>>>>>

    N in this context always means any element of the
    set of natural numbers.

    Then HHH isn't a specific program, and you are admitting that you
    "logic" is just based on FRAUD.


    We have been over this same thing too many times.

    You are right. But you can't figure out how to avoid that.


    I explained that in the part you ignored.
    When I fully answer a question endlessly
    repeating the same question after it has been
    fully answered is not acceptable.


    Inb other words, you admit to your lies, but then try to claim that they
    are not lies, just 'alternate truths' which is just another name for a lie.

    Your problem is that you have ADMITTED that you "logic" isn't based on
    real logic or the definitions of the systems you are talking about, and
    thus everything you have said is just a FRAUD.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sat Mar 22 11:48:04 2025
    On 2025-03-21 13:10:24 +0000, olcott said:

    On 3/21/2025 3:01 AM, Mikko wrote:
    On 2025-03-21 01:48:22 +0000, olcott said:

    On 3/20/2025 8:31 PM, Richard Damon wrote:
    On 3/20/25 6:43 PM, olcott wrote:
    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as >>>>>> it should mean whatever "correct emulation" means when applied to DDD. >>>>>>
    Althouth promised otherwise on the subject line the meaning of "DDD >>>>>> correctly emulated by HHH" when N is not specified is not defined. >>>>>>

    N in this context always means any element of the
    set of natural numbers.

    Then HHH isn't a specific program, and you are admitting that you
    "logic" is just based on FRAUD.


    We have been over this same thing too many times.

    You are right. But you can't figure out how to avoid that.


    I explained that in the part you ignored.
    When I fully answer a question endlessly
    repeating the same question after it has been
    fully answered is not acceptable.

    You still havn't figured out how to avoid being the over the same thing
    too many times. But noticing that you have been is a step towards the
    solution. Whether you can take another step in the same direction
    remains to be seen.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sat Mar 22 13:00:25 2025
    On 2025-03-21 13:07:38 +0000, olcott said:

    On 3/21/2025 2:59 AM, Mikko wrote:
    On 2025-03-20 22:43:34 +0000, olcott said:

    On 3/20/2025 4:16 AM, Mikko wrote:
    On 2025-03-20 02:32:43 +0000, olcott said:

    DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov  ebp,esp  ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add  esp,+04
    [00002182] 5d         pop  ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    When N steps of DDD are emulated by HHH according
    to the semantics of the x86 language then these
    N steps are emulated correctly.

    That does not make much sense to define the correct emulation of DDD as >>>> it should mean whatever "correct emulation" means when applied to DDD. >>>>
    Althouth promised otherwise on the subject line the meaning of "DDD
    correctly emulated by HHH" when N is not specified is not defined.

    N in this context always means any element of the
    set of natural numbers.

    No, it does not. It means a number that makes sense in the context and
    will be specified when the definition shall be applied.

    1,2,3...4,294,967,296 steps of DDD are correctly emulated
    by HHH and DDD never reaches its "ret" instruction and
    terminates normally.

    But your HHH does not simulate correctly more steps of DDD than your
    HHH1 does.


    This HHH is the hypothetical HHH the emulates an arbitrary number
    of steps of DDD according to the semantics of the x86 language.
    It is always at machine address 000015d2. This same HHH also
    has the ability to emulate itself emulating DDD.

    OP does not say so. Elsewhere you have said that HHH is the program at https://github.com/plolcott/x86utm/blob/master/Halt7.c (but withoout
    specifyind date or commit id). Seems that you are trying equivocation deception.

    --
    Mikko

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