1. Forum
  2. USENET
  3. sci.logic

  • Re: There are zero chances in Hell that I will quit this --- Survival of Life on Earth depends on this

    From Richard Damon@Richard@Damon-Family.org to comp.theory,comp.ai.philosophy,sci.logic on Mon Aug 4 19:06:41 2025
    From Newsgroup: sci.logic

    On 8/4/25 9:49 AM, olcott wrote:
    On 8/4/2025 6:07 AM, Richard Damon wrote:
    On 8/3/25 10:45 PM, olcott wrote:
    On 8/3/2025 9:24 PM, Richard Damon wrote:
    On 8/3/25 9:53 PM, olcott wrote:
    On 8/3/2025 8:22 PM, Richard Damon wrote:
    On 8/3/25 6:24 PM, olcott wrote:
    On 8/3/2025 12:13 PM, wij wrote:
    On Mon, 2025-08-04 at 00:45 +0800, wij wrote:
    On Sun, 2025-08-03 at 11:13 -0500, olcott wrote:
    On 8/3/2025 11:00 AM, wij wrote:
    On Sun, 2025-08-03 at 10:29 -0500, olcott wrote:

    Self-reference has been the focus of my primary research >>>>>>>>>>>> into the philosophy of:
    (a) logic
    (b) computation and
    (c) math for 22 years.

    I began with the Liar Paradox.
    That is why I own the domain LiarParadox.org.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    Just like Prolog correctly detects and rejects
    the infinitely recursive structure of the Liar
    Paradox HHH(DD) correctly detects and rejects
    the infinitely recursive structure of its input.

    I had explicitly put it in ClassGuidelines.txt to suggest >>>>>>>>>>> 'self- reference' is
    impossible to detect in (TM equvilent) programming langage. >>>>>>>>>>>

    *Yet the equivalent of self-reference is detectable*
    HHH does not know its own machine address so it cannot tell >>>>>>>>>> that DDD is actually calling itself. What it sees is that DDD >>>>>>>>>> is calling the same function with the same parameter twice >>>>>>>>>> in sequence.

    So, is HHH a function? Can a function D4 call it?

    void D4() {
    -a-a HHH(D4);
    }

    Will HHH be stuck in infinite recursion?
    How do you conclude HHH(D4)=0 is correct?


    _D4()
    [000021c3] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [000021c4] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [000021c6] 68c3210000-a-a-a-a push 000021c3 // push D4
    [000021cb] e8f3f3ffff-a-a-a-a call 000015c3 // call HHH
    [000021d0] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [000021d3] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [000021d4] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0018) [000021d4]

    D4 correctly emulated by HHH cannot possibly get
    past its own machine address [000021cb] thus the
    input to HHH(D4) does specify non-halting behavior
    no matter what the D4() that is not an input does.



    Nope. As if HHH ever returns an answer because it doesn't do the
    correct simulation and aborts, D4 will be halting.


    Like always you remain a despicable lying scumbag and change
    the words that I said as the basis of your rebuttal.

    Only changing them to the definitions of the problem from your lies
    about it.


    I really sincerely hope that this does not get you condemned
    to Hell. You certainly don't deserve that.


    No, the problem that you don't understand is that the words you use
    have a defined meaning, and in particular,
    Yes the words that I said do have a defined meaning
    in the x86 language and you deny this only because
    you are a despicable scumbag liar.



    No, they don't, as you code doesn't have meaning as it isn't complete,
    and doesn't definie (in x86 langugage) what HHH is.


    "D4 correctly emulated by HHH" is a sufficiently
    complete definition of HHH even if you never heard
    of the word "emulated". You remain a liar. I hope
    that this does not cost your soul.




    IN other wwrds you are stipulating that your HHH is DEFINED to do a
    correct simulation, and thus NEVER abort, and thus isn't a decider?

    I guess you think it can be two different things (and thus that you are stupid), or you are just admitting you are liar.

    Sorry, the words don't define HHH, and surely don't describe the HHH
    that you have been claiming to talk about.

    All you are doing it proving that words don't actualy have meaning to
    you, and you can just lie about what you are talking about.
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Richard Damon@Richard@Damon-Family.org to comp.theory,comp.ai.philosophy,sci.logic on Mon Aug 4 19:12:40 2025
    From Newsgroup: sci.logic

    On 8/4/25 10:54 AM, olcott wrote:
    On 8/4/2025 9:38 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:

    [ .... ]

    Again, irrelevant examples.
    The input for HHH is more like:

    void Finite_Recursion () {
    -a-a static int N = 5;
    -a-a if (N > 0) Finite_Recursion ();
    -a-a printf ("Olcott thinks this is never printed.\n");
    }

    Careful!-a I think you meant "if (N-- > 0) ...."-a :-)

    The fact that PO missed this shows how little attention he pays to
    detail.

    [ .... ]



    The above function has nothing to do with what I am
    claiming it is merely dodging the actual point.

    I call out any attempt at twisting the words that I
    actually said for the purpose of the strawman deception.

    _DDD()
    [00002192] 55-a-a-a-a-a-a-a-a push ebp
    [00002193] 8bec-a-a-a-a-a-a mov ebp,esp
    [00002195] 6892210000 push 00002192-a // push DDD
    [0000219a] e833f4ffff call 000015d2-a // call HHH
    [0000219f] 83c404-a-a-a-a add esp,+04
    [000021a2] 5d-a-a-a-a-a-a-a-a pop ebp
    [000021a3] c3-a-a-a-a-a-a-a-a ret
    Size in bytes:(0018) [000021a3]

    Each element of the infinite set of HHH/DDD pairs
    that emulates a natural number N number of instructions
    of DDD never reaches past machine address [0000219a].

    This is the same template as the Linz proof where
    -n.embedded_H is every Linz H that can possibly exist.

    But Linz doesn't give the TEMPLATE to the decider, but the program built
    by it, and THAT includes the HHH that it was built on, and thus every
    instance is different, so your claim about the infinite set is
    worthless, as EVERY HHH that only simulates N steps and returns 0, was
    given a DDD that when CORRECTLY simulated will hait im some number M
    N) steps, and thus HHH was just wrong.

    Thus, you are just showing that you are INFINITELY wrong, as you were
    wrong an infinite number of times there.


    -n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR
    -n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn
    (a) -n copies its input rf?-nrf-
    (b) -n invokes embedded_H rf?-nrf- rf?-nrf-
    (c) embedded_H simulates rf?-nrf- rf?-nrf- https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    No rf?-nrf- rf?-nrf- correctly simulated by -n.embedded_H can
    possibly reach its own simulated final state of rf?-n.qnrf-.



    But there is NO rf?-nrf- rf?-nrf- correctly simulated by the decider -n.embedded_H,
    so that statement is just meaningless.


    And UTM rf?-nrf- rf?-nrf- will halt for every input that H reports as non-halting,
    and thus every one of your H are wrong, as THAT (not the partial
    simulation done by H) is a proper way to determine the behavior of the
    input.

    Something you might learn if you bothered to actually look at the
    definitions of the field, instead of just guessing out of your ignorance.

    Sorry, you are just proving that you are a pathological liar that
    doesn't care what the words actually mean.
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,comp.ai.philosophy,sci.logic on Mon Aug 4 18:18:44 2025
    From Newsgroup: sci.logic

    On 8/4/2025 6:06 PM, Richard Damon wrote:
    On 8/4/25 9:49 AM, olcott wrote:
    On 8/4/2025 6:07 AM, Richard Damon wrote:
    On 8/3/25 10:45 PM, olcott wrote:
    On 8/3/2025 9:24 PM, Richard Damon wrote:
    On 8/3/25 9:53 PM, olcott wrote:
    On 8/3/2025 8:22 PM, Richard Damon wrote:
    On 8/3/25 6:24 PM, olcott wrote:
    On 8/3/2025 12:13 PM, wij wrote:
    On Mon, 2025-08-04 at 00:45 +0800, wij wrote:
    On Sun, 2025-08-03 at 11:13 -0500, olcott wrote:
    On 8/3/2025 11:00 AM, wij wrote:
    On Sun, 2025-08-03 at 10:29 -0500, olcott wrote:

    Self-reference has been the focus of my primary research >>>>>>>>>>>>> into the philosophy of:
    (a) logic
    (b) computation and
    (c) math for 22 years.

    I began with the Liar Paradox.
    That is why I own the domain LiarParadox.org.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).

    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    Just like Prolog correctly detects and rejects
    the infinitely recursive structure of the Liar
    Paradox HHH(DD) correctly detects and rejects
    the infinitely recursive structure of its input.

    I had explicitly put it in ClassGuidelines.txt to suggest >>>>>>>>>>>> 'self- reference' is
    impossible to detect in (TM equvilent) programming langage. >>>>>>>>>>>>

    *Yet the equivalent of self-reference is detectable*
    HHH does not know its own machine address so it cannot tell >>>>>>>>>>> that DDD is actually calling itself. What it sees is that DDD >>>>>>>>>>> is calling the same function with the same parameter twice >>>>>>>>>>> in sequence.

    So, is HHH a function? Can a function D4 call it?

    void D4() {
    -a-a HHH(D4);
    }

    Will HHH be stuck in infinite recursion?
    How do you conclude HHH(D4)=0 is correct?


    _D4()
    [000021c3] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [000021c4] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [000021c6] 68c3210000-a-a-a-a push 000021c3 // push D4
    [000021cb] e8f3f3ffff-a-a-a-a call 000015c3 // call HHH
    [000021d0] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [000021d3] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [000021d4] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0018) [000021d4]

    D4 correctly emulated by HHH cannot possibly get
    past its own machine address [000021cb] thus the
    input to HHH(D4) does specify non-halting behavior
    no matter what the D4() that is not an input does.



    Nope. As if HHH ever returns an answer because it doesn't do the >>>>>>> correct simulation and aborts, D4 will be halting.


    Like always you remain a despicable lying scumbag and change
    the words that I said as the basis of your rebuttal.

    Only changing them to the definitions of the problem from your lies >>>>> about it.


    I really sincerely hope that this does not get you condemned
    to Hell. You certainly don't deserve that.


    No, the problem that you don't understand is that the words you use >>>>> have a defined meaning, and in particular,
    Yes the words that I said do have a defined meaning
    in the x86 language and you deny this only because
    you are a despicable scumbag liar.



    No, they don't, as you code doesn't have meaning as it isn't
    complete, and doesn't definie (in x86 langugage) what HHH is.


    "D4 correctly emulated by HHH" is a sufficiently
    complete definition of HHH even if you never heard
    of the word "emulated". You remain a liar. I hope
    that this does not cost your soul.




    IN other wwrds you are stipulating that your HHH is DEFINED to do a
    correct simulation, and thus NEVER abort, and thus isn't a decider?


    Well that is an improvement.
    I am stipulating that HHH emulates 7 steps of D4
    according to the definition of the x86 language.

    More precisely HHH emulates the first four steps
    of D4 and then emulates an instance of itself
    emulating another instance of D4 until it reaches
    the call 000015c3 instruction of this instance.
    --
    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,comp.ai.philosophy,sci.logic on Mon Aug 4 18:23:37 2025
    From Newsgroup: sci.logic

    On 8/4/2025 6:12 PM, Richard Damon wrote:
    On 8/4/25 10:54 AM, olcott wrote:
    On 8/4/2025 9:38 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:

    [ .... ]

    Again, irrelevant examples.
    The input for HHH is more like:

    void Finite_Recursion () {
    -a-a static int N = 5;
    -a-a if (N > 0) Finite_Recursion ();
    -a-a printf ("Olcott thinks this is never printed.\n");
    }

    Careful!-a I think you meant "if (N-- > 0) ...."-a :-)

    The fact that PO missed this shows how little attention he pays to
    detail.

    [ .... ]



    The above function has nothing to do with what I am
    claiming it is merely dodging the actual point.

    I call out any attempt at twisting the words that I
    actually said for the purpose of the strawman deception.

    _DDD()
    [00002192] 55-a-a-a-a-a-a-a-a push ebp
    [00002193] 8bec-a-a-a-a-a-a mov ebp,esp
    [00002195] 6892210000 push 00002192-a // push DDD
    [0000219a] e833f4ffff call 000015d2-a // call HHH
    [0000219f] 83c404-a-a-a-a add esp,+04
    [000021a2] 5d-a-a-a-a-a-a-a-a pop ebp
    [000021a3] c3-a-a-a-a-a-a-a-a ret
    Size in bytes:(0018) [000021a3]

    Each element of the infinite set of HHH/DDD pairs
    that emulates a natural number N number of instructions
    of DDD never reaches past machine address [0000219a].

    This is the same template as the Linz proof where
    -n.embedded_H is every Linz H that can possibly exist.

    But Linz doesn't give the TEMPLATE to the decider, but the program built
    by it, and THAT includes the HHH that it was built on, and thus every instance is different, so your claim about the infinite set is
    worthless,
    In other words you are saying the Linz only proved
    that one particular instance of his own H gets the
    wrong answer for its input.
    --
    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