1. Forum
  2. USENET
  3. cplusplus

  • D simulated by H where H is a C interpreter

    From olcott@polcott333@gmail.com to comp.theory,comp.lang.c++,comp.lang.c,comp.ai.philosophy on Sat Nov 8 16:35:07 2025
    From Newsgroup: comp.lang.c++

    On 11/8/2025 3:38 PM, Kaz Kylheku wrote:
    On 2025-11-08, olcott <polcott333@gmail.com> wrote:
    On 11/8/2025 1:58 PM, Kaz Kylheku wrote:
    On 2025-11-08, olcott <polcott333@gmail.com> wrote:
    On 11/8/2025 12:10 PM, Kaz Kylheku wrote:
    On 2025-11-08, olcott <polcott333@gmail.com> wrote:
    On 11/8/2025 5:49 AM, Richard Heathfield wrote:
    On 08/11/2025 09:27, Tristan Wibberley wrote:
    On 08/11/2025 04:57, Richard Heathfield wrote:
    On 07/11/2025 20:57, olcott wrote:

    <snip>

    In my specific case D simulated by H specifies a different >>>>>>>>>> sequence of steps than D executed from main because they
    are executed in different contexts.

    If you give the 'decider' licence to choose an execution context, you >>>>>>>>> can write a universal decider easily:

    int H(int (*d)())
    {
    -a-a return 1; /* in H's context, all programs halt */
    }

    But the decider is *not* granted that licence.

    Olcott's situation doesn't require that licence in order to be solved. >>>>>>>
    Olcott's situation has no solution.


    D simulated by H cannot possibly reach its own
    simulated "return" statement final halt state
    thus the input to H(D) specifies a non-halting
    sequence of configurations.

    This is true of the above H, which returns 1 (accept).

    It is not true of any H that returns 0 for D,
    no matter how that 0 is calculated.

    You only think this because you wrongly reject the idea that the
    simulation is not finished when it is aborted by H.

    /Neglecting to simulate/ D's termination is not the same thing
    as D not having one.


    D simulated by H cannot possibly have an

    "D simulated by H" is literally not a thing. D is simulated by
    a simulator, which doesn't care whether it is driven by
    events from H, or elsewhere.

    All correct simulations of D show halting.


    Only when you dishonestly ignore that we are only
    examining the case where D calls its own simulator.

    D never calls its own simulator; there is no such thing.


    int H(char* P);

    int D()
    {
    int Halt_Status = H(D);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    The above is in test.c

    simulate.exe implements a C interpreter.
    simulate test.c runs the interpreter on
    the above source file.

    When this interpreter sees the call to H(D)
    it calls itself with the text body of D.
    --
    Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
    hits a target no one else can see." Arthur Schopenhauer
    --- Synchronet 3.21a-Linux NewsLink 1.2