1. Forum
  2. USENET
  3. comp.theory

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

    From Mikko@mikko.levanto@iki.fi to comp.theory on Thu Aug 28 10:31:58 2025
    From Newsgroup: comp.theory

    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their inputs..

    How many times must I repeat to you that DD(), the caller of HHH, should >>>> pass a *description* of itself to HHH; it is quite valid for DD to take on >>>> two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your claim.


    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour. The question whether that
    behaviour is halting or non-halting has one and only one truthful
    answer. Your HHH(DD) does not return that answer.
    --
    Mikko

    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory on Thu Aug 28 09:37:44 2025
    From Newsgroup: comp.theory

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their inputs.. >>>>>
    How many times must I repeat to you that DD(), the caller of HHH,
    should
    pass a *description* of itself to HHH; it is quite valid for DD to
    take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your claim. >>>

    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    The question whether that
    behaviour is halting or non-halting has one and only one truthful
    answer. Your HHH(DD) does not return that answer.


    DD.directly_executed and DD.correctly_simulated_by_HHH
    specify provably different sequence of steps. That you
    do not bother to check is less than no rebuttal at all.
    --
    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
  • From Mikko@mikko.levanto@iki.fi to comp.theory on Fri Aug 29 09:56:25 2025
    From Newsgroup: comp.theory

    On 2025-08-28 14:37:44 +0000, olcott said:

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their inputs.. >>>>>>
    How many times must I repeat to you that DD(), the caller of HHH, should >>>>>> pass a *description* of itself to HHH; it is quite valid for DD to take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your claim. >>>>

    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    False on the basis that you couldn't mention any contradiction
    between my statement and reality.
    --
    Mikko

    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory on Fri Aug 29 09:07:50 2025
    From Newsgroup: comp.theory

    On 8/29/2025 1:56 AM, Mikko wrote:
    On 2025-08-28 14:37:44 +0000, olcott said:

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their
    inputs..

    How many times must I repeat to you that DD(), the caller of HHH, >>>>>>> should
    pass a *description* of itself to HHH; it is quite valid for DD >>>>>>> to take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your
    claim.


    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    False on the basis that you couldn't mention any contradiction
    between my statement and reality.


    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.

    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.
    --
    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
  • From Richard Damon@Richard@Damon-Family.org to comp.theory on Fri Aug 29 22:12:39 2025
    From Newsgroup: comp.theory

    On 8/28/25 10:37 AM, olcott wrote:
    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their inputs.. >>>>>>
    How many times must I repeat to you that DD(), the caller of HHH, >>>>>> should
    pass a *description* of itself to HHH; it is quite valid for DD to >>>>>> take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your
    claim.


    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    In other words, you are just admitting that you don't beleive or
    understand in any of the basic of compuation theory, and thu every thing
    you have done is just a LIE.




    -aThe question whether that
    behaviour is halting or non-halting has one and only one truthful
    answer. Your HHH(DD) does not return that answer.


    DD.directly_executed and DD.correctly_simulated_by_HHH
    specify provably different sequence of steps. That you
    do not bother to check is less than no rebuttal at all.


    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Richard Damon@Richard@Damon-Family.org to comp.theory on Fri Aug 29 22:15:12 2025
    From Newsgroup: comp.theory

    On 8/29/25 10:07 AM, olcott wrote:
    On 8/29/2025 1:56 AM, Mikko wrote:
    On 2025-08-28 14:37:44 +0000, olcott said:

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their >>>>>>>>> inputs..

    How many times must I repeat to you that DD(), the caller of
    HHH, should
    pass a *description* of itself to HHH; it is quite valid for DD >>>>>>>> to take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your >>>>>> claim.


    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    False on the basis that you couldn't mention any contradiction
    between my statement and reality.


    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.

    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.


    But lying about it 500 times is not never lying about it.


    The problem is you have admitted that you have lied about working on the halting problem, becauwe you have admitted that you don't actually meet
    any of the basic requirements of the halting problem, and everything you
    have said is a lie based on a category error.

    Your "logic" is based on the assumption of the impossilbe as possible,
    and the right to lie about it.

    That likely has earned you a place in that lake bottom home.
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Kaz Kylheku@643-408-1753@kylheku.com to comp.theory on Sat Aug 30 06:06:09 2025
    From Newsgroup: comp.theory

    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).

    In other words, you are now agreeing with everyone else who has said the
    same thing ... which is good.
    --
    TXR Programming Language: http://nongnu.org/txr
    Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
    Mastodon: @Kazinator@mstdn.ca
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory on Sat Aug 30 13:34:12 2025
    From Newsgroup: comp.theory

    On 2025-08-29 14:07:50 +0000, olcott said:

    On 8/29/2025 1:56 AM, Mikko wrote:
    On 2025-08-28 14:37:44 +0000, olcott said:

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their inputs.. >>>>>>>>
    How many times must I repeat to you that DD(), the caller of HHH, should
    pass a *description* of itself to HHH; it is quite valid for DD to take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your claim. >>>>>>

    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    False on the basis that you couldn't mention any contradiction
    between my statement and reality.

    When I say something 500 times that does not
    count as I said it zero times.

    Saying something 500 times means the same as saying it once.
    Which is not much if you can't prove what you say.

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

    No, DD does not specify patterns. It specifies a behaviour, more
    specifically a behaviour that halts. That HHH(DD) returns 0 is
    an esselntial aspect of the specified behaviour. The rest of the
    behaviour of HHH(DD) does not affect the halting of 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.

    There is no need to if about it. It is already known that HHH(DD)
    returns 0 and that DD() halts. These facts are sufficient to infer
    that HHH is not a halt decider.

    But these details are irrelevant to the general fact that DD specifies
    one and only one bhaviour. More generally, every Turing machine specifies
    for every input one and only one behaviour.
    --
    Mikko

    --- Synchronet 3.21a-Linux NewsLink 1.2
  • 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.theory

    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
  • From olcott@polcott333@gmail.com to comp.theory on Sat Aug 30 11:22:38 2025
    From Newsgroup: comp.theory

    On 8/30/2025 5:34 AM, Mikko wrote:
    On 2025-08-29 14:07:50 +0000, olcott said:

    On 8/29/2025 1:56 AM, Mikko wrote:
    On 2025-08-28 14:37:44 +0000, olcott said:

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their >>>>>>>>>> inputs..

    How many times must I repeat to you that DD(), the caller of >>>>>>>>> HHH, should
    pass a *description* of itself to HHH; it is quite valid for DD >>>>>>>>> to take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your >>>>>>> claim.


    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    False on the basis that you couldn't mention any contradiction
    between my statement and reality.

    When I say something 500 times that does not
    count as I said it zero times.

    Saying something 500 times means the same as saying it once.
    Which is not much if you can't prove what you say.

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

    No, DD does not specify patterns. It specifies a behaviour, more
    specifically a behaviour that halts. That HHH(DD) returns 0 is
    an esselntial aspect of the specified behaviour. The rest of the
    behaviour of HHH(DD) does not affect the halting of 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.

    There is no need to if about it. It is already known that HHH(DD)
    returns 0 and that DD() halts. These facts are sufficient to infer
    that HHH is not a halt decider.

    But these details are irrelevant to the general fact that DD specifies
    one and only one bhaviour. More generally, every Turing machine specifies
    for every input one and only one behaviour.


    *Using the notion of naming conventions proposed by Kaz*

    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

    HHH(DD).exe is only being asked about DD.sim1.
    HHH cannot be asked about DD.exe
    --
    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
  • From Richard Damon@Richard@Damon-Family.org to comp.theory on Sat Aug 30 13:16:08 2025
    From Newsgroup: comp.theory

    On 8/30/25 11:08 AM, olcott wrote:
    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:

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

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

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

    Cancel double negative:

    -a-a-a 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.

    -aFrom this paragraph we can extract:

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

    OK, so we have these propositions together:

    -a-a 1. returns_zero(HHH(DD)) -> halts (DD)-a-a-a ;; from second paragraph >>
    -a-a 2. halts(DD) -> ~ correctly_simulated(DD) ;; from first paragraph

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

    -a-a 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()
    {
    -a int Halt_Status = HHH(DD);
    -a if (Halt_Status)
    -a-a-a HERE: goto HERE;
    -a return Halt_Status;
    }

    DD.exe is executed.
    DD.exe calls HHH(DD).exe

    No, it calls the subroutine HHH with parameter DD

    I guess you don't understand what a C call instruction does.

    Should that have been?
    int Halt_Status = exec("HHH.exe", "DD.exe");


    HHH.exe simulates DD.sim1

    And how does it find DD.sim1, and where is that defined.

    DD.sim1 calls HHH(DD).sim1

    Why did DD.exe envoke a HHH.exe, but DD.sim1 involkes a HHH.sim1?

    HHH.sim1 simulates DD.sim2
    DD.sim2 calls HHH(DD).sim2 ... This would repeat unless aborted

    WHich isn't valid as HHH(DD) does abort its simulation.

    if aborted then DD.exe halts

    But, since you used a false statement, just shows you are unsound.

    You logic isn't looking at the input actually given


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

    Nope, as H must answer about the H^ actually built on it, not a
    hypothetical other H that doesn't abort its simulation.


    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

    But H isn't actually a UTM, so you can't treat it as one.


    *Repeats until aborted proving non-halting*

    But only if it is in fact non-aborting.

    (a) M copies its input rf?Mrf-
    (b) M invokes M.H rf?Mrf- rf?Mrf-
    (c) M.H simulates rf?Mrf- rf?Mrf-

    If H aborts, the loop will not be infinite.


    then M.H rf?Mrf- rf?Mrf- transitions to M.qn
    causing M applied to rf?Mrf- halt


    Proving that you lied when you assumed that it would not be aborted.
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory on Sun Aug 31 11:45:47 2025
    From Newsgroup: comp.theory

    On 2025-08-30 16:22:38 +0000, olcott said:

    On 8/30/2025 5:34 AM, Mikko wrote:
    On 2025-08-29 14:07:50 +0000, olcott said:

    On 8/29/2025 1:56 AM, Mikko wrote:
    On 2025-08-28 14:37:44 +0000, olcott said:

    On 8/28/2025 2:31 AM, Mikko wrote:
    On 2025-08-23 18:05:10 +0000, olcott said:

    On 8/23/2025 12:44 PM, Richard Heathfield wrote:
    On 23/08/2025 18:12, olcott wrote:
    On 8/23/2025 12:07 PM, Mr Flibble wrote:
    On Sat, 23 Aug 2025 12:04:00 -0500, olcott wrote:

    <80-odd lines snipped>

    Turing machine deciders only compute the mapping from their inputs..

    How many times must I repeat to you that DD(), the caller of HHH, should
    pass a *description* of itself to HHH; it is quite valid for DD to take on
    two roles: caller and input.

    /Flibble

    In the same way that when Bill's identical twin brother
    Bob robs a liquor store that Bill is equally guilty
    because he looks the same as Bob.

    Please explain what you imagine your analogy clarifies about your claim.


    Turing machine deciders only compute the mapping
    from their inputs...

    When the actual behavior of the actual input to HHH(DD)
    is measured by DD correctly simulated by HHH then we
    don't conflate the actual behavior of the actual input with
    some other behavior that is not the actual behavior of the
    actual input.

    DD specifies one and only one behaviour.

    Counter factual on the basis that you didn't
    bother to check your false assumption against
    reality.

    False on the basis that you couldn't mention any contradiction
    between my statement and reality.

    When I say something 500 times that does not
    count as I said it zero times.

    Saying something 500 times means the same as saying it once.
    Which is not much if you can't prove what you say.

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

    No, DD does not specify patterns. It specifies a behaviour, more
    specifically a behaviour that halts. That HHH(DD) returns 0 is
    an esselntial aspect of the specified behaviour. The rest of the
    behaviour of HHH(DD) does not affect the halting of 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.

    There is no need to if about it. It is already known that HHH(DD)
    returns 0 and that DD() halts. These facts are sufficient to infer
    that HHH is not a halt decider.

    But these details are irrelevant to the general fact that DD specifies
    one and only one bhaviour. More generally, every Turing machine specifies
    for every input one and only one behaviour.


    *Using the notion of naming conventions proposed by Kaz*

    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

    HHH(DD).exe is only being asked about DD.sim1.
    HHH cannot be asked about DD.exe

    It is important to consider all possibilities about every "if".

    If aborted then DD.exe halts and HHH returns 0 means that HHH
    is not a halt decider.

    If not aborted then HHH does not return, which means that HHH
    is not a halt decider.

    So, in avery case, HHH is not a halt decider.
    --
    Mikko

    --- Synchronet 3.21a-Linux NewsLink 1.2