1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: The Psychology of Self-Reference [replied]

    From Fred. Zwarts@21:1/5 to All on Wed Jan 31 10:38:41 2024
    XPost: sci.logic

    Op 31.jan.2024 om 04:53 schreef olcott:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there is no >>>>>>>> logically self-consistent answer to the problem. That’s what Turing >>>>>>>> proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this question: >>>>>>> Is this sentence true or false: "this sentence is not true"?
    It is undecidable because the question itself is incorrect.

    Every yes/no question defined to have no correct yes/no answer is an >>>>>>> incorrect question.


    And the question, "Does the Computation defined by this input
    Halt?" always has a correct yes/no answer, so is a CORRECT question. >>>>>
    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.


    No, Han aborts is simulation, so it is not necessary to abort Dan, which
    is based on Han, because it aborts itself already. Then it returns a non-halting status and Dan continues with line 04.
    Han(Dan,Dan) should decide for its input Dan, which aborts itself, not
    for its non-input Dss which has an infinite recursion.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From immibis@21:1/5 to olcott on Wed Jan 31 13:25:25 2024
    XPost: sci.logic

    On 1/31/24 04:53, olcott wrote:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there is no >>>>>>>> logically self-consistent answer to the problem. That’s what Turing >>>>>>>> proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this question: >>>>>>> Is this sentence true or false: "this sentence is not true"?
    It is undecidable because the question itself is incorrect.

    Every yes/no question defined to have no correct yes/no answer is an >>>>>>> incorrect question.


    And the question, "Does the Computation defined by this input
    Halt?" always has a correct yes/no answer, so is a CORRECT question. >>>>>
    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.


    When one understands that a non-halting machine has an infinite
    execution sequence and a halting machine has a finite execution
    sequence, one sees that you are wrong.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Wed Jan 31 07:30:19 2024
    XPost: sci.logic

    On 1/30/24 10:53 PM, olcott wrote:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there is no >>>>>>>> logically self-consistent answer to the problem. That’s what Turing >>>>>>>> proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this question: >>>>>>> Is this sentence true or false: "this sentence is not true"?
    It is undecidable because the question itself is incorrect.

    Every yes/no question defined to have no correct yes/no answer is an >>>>>>> incorrect question.


    And the question, "Does the Computation defined by this input
    Halt?" always has a correct yes/no answer, so is a CORRECT question. >>>>>
    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.



    No, H is only correct to abort and report non-halting, if that exact
    same program it was looking at (using the exact same H as that H was)
    will not halt when run.

    If the code of that H is coded to abort and return non-halting, then
    that input will be Halting, and thus that H was wrong.

    This goes back to the comments about the "Illusion of Truth", as, H,
    isn't looking at the input that it was ACTUALLY given, but the
    programmer of it was reasoning (not the program, as programs don't
    "reason" only obey their programmong) if he wrote a different program,
    that didn't abort, then the input IT was given (neglecting that this
    input would be DIFFERENT, as it is based on a different H) must have its simulation aborted. But since that is a different input, you can't
    migrate that answer to the input it was actually given.

    Your problem is you just don't understand the fundamental terms you are
    using. Halting is about Specific input that decribe specific programs. "Templates" themselves are NOT valid inputs, only ways to make valid
    inputs.h
    THe above is NOT such a valid input, but needs the definition of H
    included. Once you define that this is using a specific H, you aren't
    allowed to change that for this input, which your logic does.

    Thus, you are just proving that all you are talking about is POOP and
    not halting.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From immibis@21:1/5 to olcott on Wed Jan 31 18:10:37 2024
    XPost: sci.logic

    On 1/31/24 16:36, olcott wrote:
    On 1/31/2024 6:25 AM, immibis wrote:
    On 1/31/24 04:53, olcott wrote:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there >>>>>>>>>> is no
    logically self-consistent answer to the problem. That’s what >>>>>>>>>> Turing
    proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this question: >>>>>>>>> Is this sentence true or false: "this sentence is not true"? >>>>>>>>> It is undecidable because the question itself is incorrect.

    Every yes/no question defined to have no correct yes/no answer >>>>>>>>> is an
    incorrect question.


    And the question, "Does the Computation defined by this input
    Halt?" always has a correct yes/no answer, so is a CORRECT
    question.

    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.


    When one understands that a non-halting machine has an infinite
    execution sequence and a halting machine has a finite execution
    sequence, one sees that you are wrong.


    Below I reference an infinite set of simulating termination
    analyzers

    yeah because if you referenced just one, it would be easy to prove you
    are wrong. By referencing an infinite number at the same time, you make
    the proof nonsensical, so it cannot be proven wrong because it doesn't
    even make sense, like proving the colour blue wrong.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From immibis@21:1/5 to olcott on Wed Jan 31 18:11:02 2024
    XPost: sci.logic

    On 1/31/24 16:40, olcott wrote:
    On 1/31/2024 6:30 AM, Richard Damon wrote:
    On 1/30/24 10:53 PM, olcott wrote:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there >>>>>>>>>> is no
    logically self-consistent answer to the problem. That’s what >>>>>>>>>> Turing
    proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this question: >>>>>>>>> Is this sentence true or false: "this sentence is not true"? >>>>>>>>> It is undecidable because the question itself is incorrect.

    Every yes/no question defined to have no correct yes/no answer >>>>>>>>> is an
    incorrect question.


    And the question, "Does the Computation defined by this input
    Halt?" always has a correct yes/no answer, so is a CORRECT
    question.

    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.



    No, H is only correct to abort and report non-halting, if that exact
    same program it was looking at (using the exact same H as that H was)
    will not halt when run.

    That you can't seem to fully grasp the concept of a program
    template is your own short-coming and not mine.

    Halting is about programs, not program templates. A program halts or
    doesn't. A program template does neither because it is just a template.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Wed Jan 31 20:34:10 2024
    XPost: sci.logic

    On 1/31/24 10:18 AM, olcott wrote:
    On 1/31/2024 3:38 AM, Fred. Zwarts wrote:
    Op 31.jan.2024 om 04:53 schreef olcott:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there >>>>>>>>>> is no
    logically self-consistent answer to the problem. That’s what >>>>>>>>>> Turing
    proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this question: >>>>>>>>> Is this sentence true or false: "this sentence is not true"? >>>>>>>>> It is undecidable because the question itself is incorrect.

    Every yes/no question defined to have no correct yes/no answer >>>>>>>>> is an
    incorrect question.


    And the question, "Does the Computation defined by this input
    Halt?" always has a correct yes/no answer, so is a CORRECT
    question.

    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.


    No, Han aborts is simulation, so it is not necessary to abort Dan, which

    Below I reference an infinite set of simulating termination
    analyzers that each correctly aborts its simulation of D
    and correctly rejects D as non-halting.

    When one understands that simulating termination analyzer H
    is always correct to abort any simulation that cannot possibly
    stop running unless aborted:

    Nope, as the correct simulation of the input for any H that returns
    non-halting is Halting (even if H can't do that simulation).


    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    Then every simulating termination analyzer H specified by
    the above template correctly aborts its simulation of D
    and correctly rejects D as non-halting.

    Nope, see other detailed post.


    Pages 661 to 696 of Halt7.c specify the H that does this https://github.com/plolcott/x86utm/blob/master/Halt7.c



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From immibis@21:1/5 to immibis on Mon Feb 5 22:02:18 2024
    XPost: sci.logic

    On 31/01/24 18:11, immibis wrote:
    On 1/31/24 16:40, olcott wrote:
    On 1/31/2024 6:30 AM, Richard Damon wrote:
    On 1/30/24 10:53 PM, olcott wrote:
    On 1/30/2024 8:21 PM, Richard Damon wrote:
    On 1/30/24 10:46 AM, olcott wrote:
    On 1/30/2024 9:38 AM, immibis wrote:
    On 1/30/24 03:17, olcott wrote:
    On 1/29/2024 6:48 PM, Richard Damon wrote:
    On 1/29/24 8:53 AM, olcott wrote:
    On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
    On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:

    ... professor Hehner proves my 2004 claim that the
    halting problem is an ill-formed question.

    Doesn’t matter how you phrase it, the fact remains that there >>>>>>>>>>> is no
    logically self-consistent answer to the problem. That’s what >>>>>>>>>>> Turing
    proved, and you have done nothing to change that.

    Likewise there is no logically consistent answer to this
    question:
    Is this sentence true or false: "this sentence is not true"? >>>>>>>>>> It is undecidable because the question itself is incorrect. >>>>>>>>>>
    Every yes/no question defined to have no correct yes/no answer >>>>>>>>>> is an
    incorrect question.


    And the question, "Does the Computation defined by this input >>>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT
    question.

    Yet when H is asked this question it is an entirely different
    question

    Wrong

    because the context of who is asked the question
    DOES CHANGE THE MEANING OF THE QUESTION.

    Wrong in mathematics

    It is necessarily always right it is the case that math
    guys hardly know any linguistics at all thus mistake their
    own ignorance for knowledge.

    The x86 machine code of D proves that it specifies recursive
    simulation to H.

    For this H, it specifies FINITE recursive simulation to H, so a
    HALTING behavior.


    When one understands that H is always correct to abort any
    simulation that cannot possibly stop running unless aborted

    01 int D(ptr x)  // ptr is pointer to int function
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11   H(D,D);
    12 }

    As every H specified by the above template must do then each
    and every element of this infinite set is correct to abort
    its simulation and reject its input D as non-halting.



    No, H is only correct to abort and report non-halting, if that exact
    same program it was looking at (using the exact same H as that H was)
    will not halt when run.

    That you can't seem to fully grasp the concept of a program
    template is your own short-coming and not mine.

    Halting is about programs, not program templates. A program halts or
    doesn't. A program template does neither because it is just a template.

    Olcott was not able to respond to this.

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