• Re: What is the correct halt status for HHH(DDD) ?

    From Richard Damon@21:1/5 to olcott on Sat Jul 13 13:25:20 2024
    On 7/13/24 12:48 PM, olcott wrote:
    What is the correct halt status for an input to
    a simulating termination analyzer that calls its
    own termination analyzer?

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

    void DDD()
    {
      HHH(DDD);
    }

    int main()
    {
      HHH(DDD);
    }


    Halting.

    Since HHH defined to be a termination analyzer, by that definition it
    must return to its caller.

    Since DDD has no inputs, its behavior isn't affected by any inputs, and
    thus DDD will halt for ALL input conditions, so for HHH to be a correct termination analysizer it needs to return the value to indicate Halting.

    Your version can't do that, so either fails to be a proper decider, or
    gets the wrong answer.

    The Flibble version could get this correct, if the structure allows it
    to properly detect that DDD is actually calling HHH, which puts us
    outside of the Turing Equivalency rules, but can be done in that C code.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jul 13 14:33:16 2024
    On 7/13/24 2:15 PM, olcott wrote:
    On 7/13/2024 12:25 PM, Richard Damon wrote:
    On 7/13/24 12:48 PM, olcott wrote:
    What is the correct halt status for an input to
    a simulating termination analyzer that calls its
    own termination analyzer?

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

    void DDD()
    {
       HHH(DDD);
    }

    int main()
    {
       HHH(DDD);
    }


    Halting.

    Since HHH defined to be a termination analyzer, by that definition it
    must return to its caller.

    Since DDD has no inputs, its behavior isn't affected by any inputs,
    and thus DDD will halt for ALL input conditions, so

    You are stupidly saying that Infinite_Loop() will halt because
    it has no inputs.


    Where did I say no input means halting?

    I said that since DDD has no inputs, a Termination analyizer doesn't
    need to look over all inputs, as there are no inputs to affect it.

    Maybe you forget that a Termination Analyzer is not the same thing as a
    Halt Decider.

    A Halt Decider determines if the given program will halt for the given
    input, and needs to be given both (if the program takes an input).

    A Termination Analyzer determines if a given program will halt for every possible input, and thus is only given the program, and not the input to
    test.


    Note, for Infinite_Loop below, it IS possible for a simulator to detect
    a condition in a finite amount of time that an unbounded emulation would
    never halt, so can answer correctly non-halting.

    The problem with trying to apply that to DDD is it isn't true, give the
    DDD that uses the HHH that tries to think it has determined it to never
    halt to a actual pure emulator (and thus DDD still calls that HHH that
    thinks it has determined that DDD will not halt and aborts its emulation
    and returns) then the pure emulatior will see that HHH make that
    decisioin and return to DDD which will return.

    Thus HHH can never actually make that same conclusion. You logic is
    incorrrect as you presume the input changes with the emulator, but it
    actually doesn't, it changes with the emulator you have stated is the
    one that gives the correct answer, which you can't change in the middle
    of the problem.

    void Infinite_Loop()
    {
      HERE: goto HERE;
    }

    for HHH to be a correct termination analysizer it needs to return the
    value to indicate Halting.

    Yes

    And thus, it WILL return that value to the DDD that calls it, and that
    DDD will halt.


    Your version

    I am asking What is the correct halt status for HHH(DDD)
    that at least one element of every possible pure function
    HHH can provide.


    The only correct answer it is able to give is Halt.

    The problem is your algorithm as defined can never determine that this
    is the correct answer.

    can't do that, so either fails to be a proper decider, or gets the
    wrong answer.

    The Flibble version could get this correct, if the structure allows it
    to properly detect that DDD is actually calling HHH, which puts us
    outside of the Turing Equivalency rules, but can be done in that C code.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jul 13 15:15:01 2024
    On 7/13/24 2:48 PM, olcott wrote:
    On 7/13/2024 12:25 PM, Richard Damon wrote:
    On 7/13/24 12:48 PM, olcott wrote:
    What is the correct halt status for an input to
    a simulating termination analyzer that calls its
    own termination analyzer?

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

    void DDD()
    {
       HHH(DDD);
    }

    int main()
    {
       HHH(DDD);
    }


    Halting.

    Since HHH defined to be a termination analyzer, by that definition it
    must return to its caller.

    Since DDD has no inputs, its behavior isn't affected by any inputs,
    and thus DDD will halt for ALL input conditions,

    Stupidly false. Its behavior is not affected
    by inputs because it has not inputs is the not
    stupid way to say it.


    So, you think its behavior IS affected by th e inputs it doesn't take?

    Programs, in general, have inputs.

    If they don't use an input, then the set of all possible inputs is just
    the set of one input, the empty input, and all other options are just
    ignored.

    I guess you just don't understand how to formally say things, a skill
    you avoided as being clear with your statements boxes you into following
    them.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Sun Jul 14 11:00:23 2024
    On 2024-07-13 18:15:35 +0000, olcott said:

    On 7/13/2024 12:25 PM, Richard Damon wrote:
    On 7/13/24 12:48 PM, olcott wrote:
    What is the correct halt status for an input to
    a simulating termination analyzer that calls its
    own termination analyzer?

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

    void DDD()
    {
       HHH(DDD);
    }

    int main()
    {
       HHH(DDD);
    }


    Halting.

    Since HHH defined to be a termination analyzer, by that definition it
    must return to its caller.

    Since DDD has no inputs, its behavior isn't affected by any inputs, and
    thus DDD will halt for ALL input conditions, so

    You are stupidly saying that Infinite_Loop() will halt because
    it has no inputs.

    void Infinite_Loop()
    {
    HERE: goto HERE;
    }

    You are stupidly saying that Infinite loop is executed as a part of HHH.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Mon Jul 15 10:22:28 2024
    On 2024-07-14 14:36:52 +0000, olcott said:

    On 7/14/2024 3:00 AM, Mikko wrote:
    On 2024-07-13 18:15:35 +0000, olcott said:

    On 7/13/2024 12:25 PM, Richard Damon wrote:
    On 7/13/24 12:48 PM, olcott wrote:
    What is the correct halt status for an input to
    a simulating termination analyzer that calls its
    own termination analyzer?

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

    void DDD()
    {
       HHH(DDD);
    }

    int main()
    {
       HHH(DDD);
    }


    Halting.

    Since HHH defined to be a termination analyzer, by that definition it
    must return to its caller.

    Since DDD has no inputs, its behavior isn't affected by any inputs, and >>>> thus DDD will halt for ALL input conditions, so

    You are stupidly saying that Infinite_Loop() will halt because
    it has no inputs.

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    You are stupidly saying that Infinite loop is executed as a part of HHH.


    Infinite_Loop() is emulated in its own process context.

    In that case, how do you justify "You are stupidly saying"?

    --
    Mikko

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