1. Forum
  2. USENET
  3. comp.ai.philosophy

  • Re: Measuring the actual behavior of the actual input to HHH(DD)

    From olcott@polcott333@gmail.com to comp.theory,comp.lang.c++,comp.lang.c,comp.ai.philosophy on Sat Aug 30 10:08:14 2025
    From Newsgroup: comp.ai.philosophy

    On 8/30/2025 1:06 AM, Kaz Kylheku wrote:
    On 2025-08-29, olcott <polcott333@gmail.com> wrote:
    When I say something 500 times that does not
    count as I said it zero times.

    DD correctly simulated by HHH specifies the
    non-halting behavior pattern of recursive
    simulation.

    Using a bit of logical formalism:

    correctly_simulated(DD) -> ~ halts(DD)

    Given P -> Q, we can derive the contrapositive ~Q -> ~P.
    In this case:

    ~ ~ halts(DD) -> ~ correctly_simulated(DD)

    Cancel double negative:

    halts(DD) -> ~ correctly_simulated(DD)

    If HHH can recognize this repeating state as
    a pure function of its inputs then HHH(DD)
    returns 0 for non-halting and DD() halts.

    From this paragraph we can extract:

    returns_zero(HHH(DD)) -> halts (DD)

    OK, so we have these propositions together:

    1. returns_zero(HHH(DD)) -> halts (DD) ;; from second paragraph

    2. halts(DD) -> ~ correctly_simulated(DD) ;; from first paragraph

    By the transitive property of the arrow: P -> Q ^ Q -> R => P -> R, therefore we have:

    3. returns_zero(HHH(DD)) -> ~ correctly_simulated(DD)

    You are logically arguing that if HHH(DD) returns
    zero, then DD is not correctly simulated (because it halts).


    We just use your idea of establishing
    naming conventions:

    HHH(DD).exe returns 0 because DD.sim1
    cannot possibly halt then DD.exe halts.
    DD.exe is outside of the scope of HHH.exe.

    typedef int (*ptr)();
    int HHH(ptr P);

    int DD()
    {
    int Halt_Status = HHH(DD);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    DD.exe is executed.
    DD.exe calls HHH(DD).exe
    HHH.exe simulates DD.sim1
    DD.sim1 calls HHH(DD).sim1
    HHH.sim1 simulates DD.sim2
    DD.sim2 calls HHH(DD).sim2 ... This would repeat unless aborted
    if aborted then DD.exe halts

    This exact same thing happens with the Linz
    Turing Machine based proof.

    Machine M contains simulating halt decider H based on a UTM
    M.q0 rf?Mrf- reo* M.H rf?Mrf- rf?Mrf- reo* M.reR
    M.q0 rf?Mrf- reo* M.H rf?Mrf- rf?Mrf- reo* M.qn

    *Repeats until aborted proving non-halting*
    (a) M copies its input rf?Mrf-
    (b) M invokes M.H rf?Mrf- rf?Mrf-
    (c) M.H simulates rf?Mrf- rf?Mrf-

    then M.H rf?Mrf- rf?Mrf- transitions to M.qn
    causing M applied to rf?Mrf- halt
    --
    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