On 2/10/2024 4:12 AM, Mikko wrote:
> On 2024-02-09 21:57:55 +0000, immibis said:
>
>> On 9/02/24 22:33, olcott wrote:
>>> Then Linz notices that both answers that Ĥ provides are the wrong
>>> answer.
>>
>> Ĥ cannot provide both answers. It only provides one answer.
>
> Or none.
>

embedded_H could be encoded with every detail all of knowledge that can
be expressed using language. This means that embedded_H is not
restricted by typical conventions. embedded_H could output a text string
swearing at you in English for trying to trick it. This would not be a
wrong answer.

Boolean True(English, "this sentence is not true")
would be required to do this same sort of thing.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2/10/2024 7:35 AM, Richard Damon wrote:
> On 2/10/24 12:33 AM, olcott wrote:
>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>> On 2/9/24 11:24 PM, olcott wrote:
>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding of
>>>>>>>>>>>>>>>>>> Ĥ that can
>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to give
>>>>>>>>>>>>>>>>> the right answer on all inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what it
>>>>>>>>>>>>>>> says.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So the Halting Question, does the computation described by
>>>>>>>>>>>>> the input Halt? isn't a self-contradictory question, as it
>>>>>>>>>>>>> always has a correct answer, the opposite of what H gives
>>>>>>>>>>>>> (if it gives one).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty times
>>>>>>>>>>>> before you get it? (it took me twenty years to get it this
>>>>>>>>>>>> simple)
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn
>>>>>>>>>>>> are the wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H that
>>>>>>>>>>> is in it does.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Do you understand that every possible element of an infinite
>>>>>>>>>>>> set is more than one element?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>
>>>>>>>>>>> The Haltig problem is about making a decider that answers the
>>>>>>>>>>> Halting QUestion which asks the decider about the SPECIFIC
>>>>>>>>>>> COMPUTATION (a specific program/data) that the input describes.
>>>>>>>>>>>
>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>> just not the one the decider gave.
>>>>>>>>
>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to contradict
>>>>>>>> every value that each embedded_H returns for the infinite set of
>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory question.
>>>>>>>
>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>
>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>> describes a Halting Computation or not.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>> to be self-contradictory.
>>>>>>
>>>>> So?
>>>>>
>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>
>>>>>> The issue is not that the most powerful model of computation is
>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>> to be self-contradictory.
>>>>>
>>>>> But it shows that the simple problem, for which we have good
>>>>> reasons for wanting an answer, can not be computed by this most
>>>>> powerful model of computation.
>>>>>
>>>>
>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>> Do you halt on your own Turing Machine Description?
>>>
>>> No, it is asking if the computation described by the input will halt
>>> when run.
>>>
>>
>> Linz and I have been referring to the actual computation of
>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>
> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to qn to
> say the computation that its input (Ĥ) (Ĥ) represents, that is Ĥ (Ĥ)
> will not halt.
>
> Thus you H is just WRONG.
>

On 2/10/24 10:06 AM, olcott wrote:
> On 2/10/2024 7:35 AM, Richard Damon wrote:
>> On 2/10/24 12:33 AM, olcott wrote:
>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding of
>>>>>>>>>>>>>>>>>>> Ĥ that can
>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to give
>>>>>>>>>>>>>>>>>> the right answer on all inputs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So the Halting Question, does the computation described by
>>>>>>>>>>>>>> the input Halt? isn't a self-contradictory question, as it
>>>>>>>>>>>>>> always has a correct answer, the opposite of what H gives
>>>>>>>>>>>>>> (if it gives one).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>> times before you get it? (it took me twenty years to get it
>>>>>>>>>>>>> this simple)
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn
>>>>>>>>>>>>> are the wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H that
>>>>>>>>>>>> is in it does.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>
>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>> input describes.
>>>>>>>>>>>>
>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>
>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to contradict
>>>>>>>>> every value that each embedded_H returns for the infinite set of
>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>> question.
>>>>>>>>
>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>
>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>> describes a Halting Computation or not.
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>> to be self-contradictory.
>>>>>>>
>>>>>> So?
>>>>>>
>>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>>
>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>> to be self-contradictory.
>>>>>>
>>>>>> But it shows that the simple problem, for which we have good
>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>> powerful model of computation.
>>>>>>
>>>>>
>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>> Do you halt on your own Turing Machine Description?
>>>>
>>>> No, it is asking if the computation described by the input will halt
>>>> when run.
>>>>
>>>
>>> Linz and I have been referring to the actual computation of
>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>
>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to qn
>> to say the computation that its input (Ĥ) (Ĥ) represents, that is Ĥ
>> (Ĥ) will not halt.
>>
>> Thus you H is just WRONG.
>>
>
> embedded_H could be encoded with every detail all of knowledge that can
> be expressed using language. This means that embedded_H is not
> restricted by typical conventions. embedded_H could output a text string
> swearing at you in English for trying to trick it. This would not be a
> wrong answer.

On 2/10/2024 9:29 AM, Richard Damon wrote:
> On 2/10/24 10:06 AM, olcott wrote:
>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>> On 2/10/24 12:33 AM, olcott wrote:
>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what H
>>>>>>>>>>>>>>> gives (if it gives one).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn
>>>>>>>>>>>>>> are the wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>
>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>> contradict
>>>>>>>>>> every value that each embedded_H returns for the infinite set of
>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>> question.
>>>>>>>>>
>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>
>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>> to be self-contradictory.
>>>>>>>>
>>>>>>> So?
>>>>>>>
>>>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>>>
>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>> to be self-contradictory.
>>>>>>>
>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>> powerful model of computation.
>>>>>>>
>>>>>>
>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>> Do you halt on your own Turing Machine Description?
>>>>>
>>>>> No, it is asking if the computation described by the input will
>>>>> halt when run.
>>>>>
>>>>
>>>> Linz and I have been referring to the actual computation of
>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>
>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to qn
>>> to say the computation that its input (Ĥ) (Ĥ) represents, that is Ĥ
>>> (Ĥ) will not halt.
>>>
>>> Thus you H is just WRONG.
>>>
>>
>> embedded_H could be encoded with every detail all of knowledge that can
>> be expressed using language. This means that embedded_H is not
>> restricted by typical conventions. embedded_H could output a text string
>> swearing at you in English for trying to trick it. This would not be a
>> wrong answer.
>
> Embedded H is restricted to only be able to do what is computable.
>
> Since Embedded_H is (at least by your claims) an exact copy of the
> Turing Machine H, it can only do what a Turing Machine can do.
>

On 2/10/24 11:18 AM, olcott wrote:
> On 2/10/2024 9:29 AM, Richard Damon wrote:
>> On 2/10/24 10:06 AM, olcott wrote:
>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied to
>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>> contradict
>>>>>>>>>>> every value that each embedded_H returns for the infinite set of
>>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>> question.
>>>>>>>>>>
>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>
>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>>> to be self-contradictory.
>>>>>>>>>
>>>>>>>> So?
>>>>>>>>
>>>>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>>>>
>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>> to be self-contradictory.
>>>>>>>>
>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>> powerful model of computation.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>
>>>>>> No, it is asking if the computation described by the input will
>>>>>> halt when run.
>>>>>>
>>>>>
>>>>> Linz and I have been referring to the actual computation of
>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>
>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that is
>>>> Ĥ (Ĥ) will not halt.
>>>>
>>>> Thus you H is just WRONG.
>>>>
>>>
>>> embedded_H could be encoded with every detail all of knowledge that can
>>> be expressed using language. This means that embedded_H is not
>>> restricted by typical conventions. embedded_H could output a text string
>>> swearing at you in English for trying to trick it. This would not be a
>>> wrong answer.
>>
>> Embedded H is restricted to only be able to do what is computable.
>>
>> Since Embedded_H is (at least by your claims) an exact copy of the
>> Turing Machine H, it can only do what a Turing Machine can do.
>>
>
> When Embedded_H has encoded within it all of human knowledge that can
> be encoded within language then it ceases to be restricted to Boolean.
> This enables Embedded_H to do anything that a human mind can do.
>
>> So, it CAN'T do what you claim, so you are a LIAR.
>>>
>>> enum Boolean {
>>>    TRUE,
>>>    FALSE,
>>>    NEITHER
>>> };
>>>
>>> Boolean True(English, "this sentence is not true")
>>> would be required to do this same sort of thing.
>>>
>>>
>>
>> But CAN it? Remember, programs can only do what programs can do, which
>> is based on the instructions they are composed of
>>
>> You are just too stupid to understand this.
>
> It is not that I am stupid it is that you cannot think outside the box
> of conventional wisdom. There is nothing impossible about a TM that
> can communicate in English and understand the meaning of words to the
> same extent that human experts do.
>

On 2/10/2024 10:35 AM, Richard Damon wrote:
> On 2/10/24 11:18 AM, olcott wrote:
>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>> On 2/10/24 10:06 AM, olcott wrote:
>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>> report its own halt status.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is
>>>>>>>>>>>>>>>>>>>> an incorrect
>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>> what it says.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied
>>>>>>>>>>>>>>>> to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>> thing that Halting quesiton is about.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>> contradict
>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>> set of
>>>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>> question.
>>>>>>>>>>>
>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>
>>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>>> talk about has a correct answer to it, as every specific
>>>>>>>>>>> input describes a Halting Computation or not.
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>
>>>>>>>>> So?
>>>>>>>>>
>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>>>>>
>>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>> to be self-contradictory.
>>>>>>>>>
>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>>> powerful model of computation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>
>>>>>>> No, it is asking if the computation described by the input will
>>>>>>> halt when run.
>>>>>>>
>>>>>>
>>>>>> Linz and I have been referring to the actual computation of
>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>
>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that
>>>>> is Ĥ (Ĥ) will not halt.
>>>>>
>>>>> Thus you H is just WRONG.
>>>>>
>>>>
>>>> embedded_H could be encoded with every detail all of knowledge that can
>>>> be expressed using language. This means that embedded_H is not
>>>> restricted by typical conventions. embedded_H could output a text
>>>> string
>>>> swearing at you in English for trying to trick it. This would not be a
>>>> wrong answer.
>>>
>>> Embedded H is restricted to only be able to do what is computable.
>>>
>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>
>>
>> When Embedded_H has encoded within it all of human knowledge that can
>> be encoded within language then it ceases to be restricted to Boolean.
>> This enables Embedded_H to do anything that a human mind can do.
>>
>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>
>>>> enum Boolean {
>>>>    TRUE,
>>>>    FALSE,
>>>>    NEITHER
>>>> };
>>>>
>>>> Boolean True(English, "this sentence is not true")
>>>> would be required to do this same sort of thing.
>>>>
>>>>
>>>
>>> But CAN it? Remember, programs can only do what programs can do,
>>> which is based on the instructions they are composed of
>>>
>>> You are just too stupid to understand this.
>>
>> It is not that I am stupid it is that you cannot think outside the box
>> of conventional wisdom. There is nothing impossible about a TM that
>> can communicate in English and understand the meaning of words to the
>> same extent that human experts do.
>>
>
> You don't understand that your program must follow the rules of a program!
>

On 02/10/2024 08:18 AM, olcott wrote:
> On 2/10/2024 9:29 AM, Richard Damon wrote:
>> On 2/10/24 10:06 AM, olcott wrote:
>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // wrong
>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied to
>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>> contradict
>>>>>>>>>>> every value that each embedded_H returns for the infinite set of
>>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>> question.
>>>>>>>>>>
>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>
>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>>> to be self-contradictory.
>>>>>>>>>
>>>>>>>> So?
>>>>>>>>
>>>>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>>>>
>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>> to be self-contradictory.
>>>>>>>>
>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>> powerful model of computation.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>
>>>>>> No, it is asking if the computation described by the input will
>>>>>> halt when run.
>>>>>>
>>>>>
>>>>> Linz and I have been referring to the actual computation of
>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>
>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that is
>>>> Ĥ (Ĥ) will not halt.
>>>>
>>>> Thus you H is just WRONG.
>>>>
>>>
>>> embedded_H could be encoded with every detail all of knowledge that can
>>> be expressed using language. This means that embedded_H is not
>>> restricted by typical conventions. embedded_H could output a text string
>>> swearing at you in English for trying to trick it. This would not be a
>>> wrong answer.
>>
>> Embedded H is restricted to only be able to do what is computable.
>>
>> Since Embedded_H is (at least by your claims) an exact copy of the
>> Turing Machine H, it can only do what a Turing Machine can do.
>>
>
> When Embedded_H has encoded within it all of human knowledge that can
> be encoded within language then it ceases to be restricted to Boolean.
> This enables Embedded_H to do anything that a human mind can do.
>
>> So, it CAN'T do what you claim, so you are a LIAR.
>>>
>>> enum Boolean {
>>> TRUE,
>>> FALSE,
>>> NEITHER
>>> };
>>>
>>> Boolean True(English, "this sentence is not true")
>>> would be required to do this same sort of thing.
>>>
>>>
>>
>> But CAN it? Remember, programs can only do what programs can do, which
>> is based on the instructions they are composed of
>>
>> You are just too stupid to understand this.
>
> It is not that I am stupid it is that you cannot think outside the box
> of conventional wisdom. There is nothing impossible about a TM that
> can communicate in English and understand the meaning of words to the
> same extent that human experts do.
>

On 2/10/2024 12:28 PM, Ross Finlayson wrote:
> On 02/10/2024 08:18 AM, olcott wrote:
>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>> On 2/10/24 10:06 AM, olcott wrote:
>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied to
>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>> contradict
>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>> set of
>>>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>> question.
>>>>>>>>>>>
>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>
>>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>
>>>>>>>>> So?
>>>>>>>>>
>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are wrong.
>>>>>>>>>
>>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>> to be self-contradictory.
>>>>>>>>>
>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>>> powerful model of computation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>
>>>>>>> No, it is asking if the computation described by the input will
>>>>>>> halt when run.
>>>>>>>
>>>>>>
>>>>>> Linz and I have been referring to the actual computation of
>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>
>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that is
>>>>> Ĥ (Ĥ) will not halt.
>>>>>
>>>>> Thus you H is just WRONG.
>>>>>
>>>>
>>>> embedded_H could be encoded with every detail all of knowledge that can
>>>> be expressed using language. This means that embedded_H is not
>>>> restricted by typical conventions. embedded_H could output a text
>>>> string
>>>> swearing at you in English for trying to trick it. This would not be a
>>>> wrong answer.
>>>
>>> Embedded H is restricted to only be able to do what is computable.
>>>
>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>
>>
>> When Embedded_H has encoded within it all of human knowledge that can
>> be encoded within language then it ceases to be restricted to Boolean.
>> This enables Embedded_H to do anything that a human mind can do.
>>
>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>
>>>> enum Boolean {
>>>>    TRUE,
>>>>    FALSE,
>>>>    NEITHER
>>>> };
>>>>
>>>> Boolean True(English, "this sentence is not true")
>>>> would be required to do this same sort of thing.
>>>>
>>>>
>>>
>>> But CAN it? Remember, programs can only do what programs can do, which
>>> is based on the instructions they are composed of
>>>
>>> You are just too stupid to understand this.
>>
>> It is not that I am stupid it is that you cannot think outside the box
>> of conventional wisdom. There is nothing impossible about a TM that
>> can communicate in English and understand the meaning of words to the
>> same extent that human experts do.
>>
>
> I see you guys are still trying to invalidate each others' deciders.
>
> In a Comenius language, the Liar: is just the prototype of a fallacy,
> sharing as it does properties with "the sputnik of quantification",
> "the Russell set", "ORD the order type of ordinals", that when the
> self-same Universe of Objects is just truisms the Comenius language,

On 2/10/24 11:53 AM, olcott wrote:
> On 2/10/2024 10:35 AM, Richard Damon wrote:
>> On 2/10/24 11:18 AM, olcott wrote:
>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every
>>>>>>>>>>>>>>>>>>>>>>> encoding of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing
>>>>>>>>>>>>>>>>>>>>>>> machines such that each one
>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>> report its own halt status.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is
>>>>>>>>>>>>>>>>>>>>> an incorrect
>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>> what it says.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation
>>>>>>>>>>>>>>>>>> described by the input Halt? isn't a
>>>>>>>>>>>>>>>>>> self-contradictory question, as it always has a
>>>>>>>>>>>>>>>>>> correct answer, the opposite of what H gives (if it
>>>>>>>>>>>>>>>>>> gives one).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to
>>>>>>>>>>>>>>>>> get it this simple)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied
>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>> thing that Halting quesiton is about.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that
>>>>>>>>>>>>>>>> answers the Halting QUestion which asks the decider
>>>>>>>>>>>>>>>> about the SPECIFIC COMPUTATION (a specific program/data)
>>>>>>>>>>>>>>>> that the input describes.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that EVERY element of that set had a correct
>>>>>>>>>>>>>> answer, just not the one the decider gave.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>> contradict
>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>> set of
>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>> question.
>>>>>>>>>>>>
>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set
>>>>>>>>>>>> you talk about has a correct answer to it, as every specific
>>>>>>>>>>>> input describes a Halting Computation or not.
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>
>>>>>>>>>> So?
>>>>>>>>>>
>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>
>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>> reasons for wanting an answer, can not be computed by this
>>>>>>>>>> most powerful model of computation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>
>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>> halt when run.
>>>>>>>>
>>>>>>>
>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>
>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that
>>>>>> is Ĥ (Ĥ) will not halt.
>>>>>>
>>>>>> Thus you H is just WRONG.
>>>>>>
>>>>>
>>>>> embedded_H could be encoded with every detail all of knowledge that
>>>>> can
>>>>> be expressed using language. This means that embedded_H is not
>>>>> restricted by typical conventions. embedded_H could output a text
>>>>> string
>>>>> swearing at you in English for trying to trick it. This would not be a
>>>>> wrong answer.
>>>>
>>>> Embedded H is restricted to only be able to do what is computable.
>>>>
>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>
>>>
>>> When Embedded_H has encoded within it all of human knowledge that can
>>> be encoded within language then it ceases to be restricted to Boolean.
>>> This enables Embedded_H to do anything that a human mind can do.
>>>
>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>
>>>>> enum Boolean {
>>>>>    TRUE,
>>>>>    FALSE,
>>>>>    NEITHER
>>>>> };
>>>>>
>>>>> Boolean True(English, "this sentence is not true")
>>>>> would be required to do this same sort of thing.
>>>>>
>>>>>
>>>>
>>>> But CAN it? Remember, programs can only do what programs can do,
>>>> which is based on the instructions they are composed of
>>>>
>>>> You are just too stupid to understand this.
>>>
>>> It is not that I am stupid it is that you cannot think outside the box
>>> of conventional wisdom. There is nothing impossible about a TM that
>>> can communicate in English and understand the meaning of words to the
>>> same extent that human experts do.
>>>
>>
>> You don't understand that your program must follow the rules of a
>> program!
>>
>
> It need not follow any arbitrary conventions.
>
>> IF you think what you claim is possible, DO IT.
>>
>> Remember though, that H has a defined "API", it is to give it's answer
>> in a specific way, and each option has a defined meaning.
>>
>
> The API could output its halt status determination using an
> infinite set of equivalent natural language expressions.
>
>> Perhaps it could write a message in English on its tape, but then
>> going to Qn, it is clearly stating that its answer to the question it
>> was given was "The computation that the input I was given represents,
>> WILL NOT HALT, when it is run". And EXACTLY That. It doesn't matter
>> what was written to the tape, as that doesn't have significance to the
>> API.
>>
>
> It could alternatively cuss you out for trying to cheat using an
> infinite set of equivalent natural language expressions.

On 2/10/24 1:52 PM, olcott wrote:
> On 2/10/2024 12:28 PM, Ross Finlayson wrote:
>> On 02/10/2024 08:18 AM, olcott wrote:
>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied to
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>> contradict
>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>> set of
>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every element of
>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>> question.
>>>>>>>>>>>>
>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>
>>>>>>>>>> So?
>>>>>>>>>>
>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>
>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>>>> powerful model of computation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>
>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>> halt when run.
>>>>>>>>
>>>>>>>
>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>
>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that is
>>>>>> Ĥ (Ĥ) will not halt.
>>>>>>
>>>>>> Thus you H is just WRONG.
>>>>>>
>>>>>
>>>>> embedded_H could be encoded with every detail all of knowledge that
>>>>> can
>>>>> be expressed using language. This means that embedded_H is not
>>>>> restricted by typical conventions. embedded_H could output a text
>>>>> string
>>>>> swearing at you in English for trying to trick it. This would not be a
>>>>> wrong answer.
>>>>
>>>> Embedded H is restricted to only be able to do what is computable.
>>>>
>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>
>>>
>>> When Embedded_H has encoded within it all of human knowledge that can
>>> be encoded within language then it ceases to be restricted to Boolean.
>>> This enables Embedded_H to do anything that a human mind can do.
>>>
>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>
>>>>> enum Boolean {
>>>>>    TRUE,
>>>>>    FALSE,
>>>>>    NEITHER
>>>>> };
>>>>>
>>>>> Boolean True(English, "this sentence is not true")
>>>>> would be required to do this same sort of thing.
>>>>>
>>>>>
>>>>
>>>> But CAN it? Remember, programs can only do what programs can do, which
>>>> is based on the instructions they are composed of
>>>>
>>>> You are just too stupid to understand this.
>>>
>>> It is not that I am stupid it is that you cannot think outside the box
>>> of conventional wisdom. There is nothing impossible about a TM that
>>> can communicate in English and understand the meaning of words to the
>>> same extent that human experts do.
>>>
>>
>> I see you guys are still trying to invalidate each others' deciders.
>>
>> In a Comenius language, the Liar: is just the prototype of a fallacy,
>> sharing as it does properties with "the sputnik of quantification",
>> "the Russell set", "ORD the order type of ordinals", that when the
>> self-same Universe of Objects is just truisms the Comenius language,
>
> Yes this also gets rid of the issue of undecidability.
> An expression of language is either true or ~true, thus
> unprovable from axioms merely mean untrue and cannot
> mean undecidable.

On 2/10/2024 2:14 PM, Richard Damon wrote:
> On 2/10/24 11:53 AM, olcott wrote:
>> On 2/10/2024 10:35 AM, Richard Damon wrote:
>>> On 2/10/24 11:18 AM, olcott wrote:
>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ //
>>>>>>>>>>>>>>>>>>>>>>>> wrong answer
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   //
>>>>>>>>>>>>>>>>>>>>>>>> wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every
>>>>>>>>>>>>>>>>>>>>>>>> encoding of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing
>>>>>>>>>>>>>>>>>>>>>>>> machines such that each one
>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>> report its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is
>>>>>>>>>>>>>>>>>>>>>> an incorrect
>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>> what it says.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation
>>>>>>>>>>>>>>>>>>> described by the input Halt? isn't a
>>>>>>>>>>>>>>>>>>> self-contradictory question, as it always has a
>>>>>>>>>>>>>>>>>>> correct answer, the opposite of what H gives (if it
>>>>>>>>>>>>>>>>>>> gives one).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to
>>>>>>>>>>>>>>>>>> get it this simple)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied
>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>> thing that Halting quesiton is about.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that
>>>>>>>>>>>>>>>>> answers the Halting QUestion which asks the decider
>>>>>>>>>>>>>>>>> about the SPECIFIC COMPUTATION (a specific
>>>>>>>>>>>>>>>>> program/data) that the input describes.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct
>>>>>>>>>>>>>>> answer, just not the one the decider gave.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set
>>>>>>>>>>>>> you talk about has a correct answer to it, as every
>>>>>>>>>>>>> specific input describes a Halting Computation or not.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>> defined
>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>> So?
>>>>>>>>>>>
>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>
>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>> reasons for wanting an answer, can not be computed by this
>>>>>>>>>>> most powerful model of computation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>
>>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>>> halt when run.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>
>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes
>>>>>>> to qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>> that is Ĥ (Ĥ) will not halt.
>>>>>>>
>>>>>>> Thus you H is just WRONG.
>>>>>>>
>>>>>>
>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>> that can
>>>>>> be expressed using language. This means that embedded_H is not
>>>>>> restricted by typical conventions. embedded_H could output a text
>>>>>> string
>>>>>> swearing at you in English for trying to trick it. This would not
>>>>>> be a
>>>>>> wrong answer.
>>>>>
>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>
>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>
>>>>
>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>> be encoded within language then it ceases to be restricted to Boolean.
>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>
>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>
>>>>>> enum Boolean {
>>>>>>    TRUE,
>>>>>>    FALSE,
>>>>>>    NEITHER
>>>>>> };
>>>>>>
>>>>>> Boolean True(English, "this sentence is not true")
>>>>>> would be required to do this same sort of thing.
>>>>>>
>>>>>>
>>>>>
>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>> which is based on the instructions they are composed of
>>>>>
>>>>> You are just too stupid to understand this.
>>>>
>>>> It is not that I am stupid it is that you cannot think outside the box
>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>> can communicate in English and understand the meaning of words to the
>>>> same extent that human experts do.
>>>>
>>>
>>> You don't understand that your program must follow the rules of a
>>> program!
>>>
>>
>> It need not follow any arbitrary conventions.
>>
>>> IF you think what you claim is possible, DO IT.
>>>
>>> Remember though, that H has a defined "API", it is to give it's
>>> answer in a specific way, and each option has a defined meaning.
>>>
>>
>> The API could output its halt status determination using an
>> infinite set of equivalent natural language expressions.
>>
>>> Perhaps it could write a message in English on its tape, but then
>>> going to Qn, it is clearly stating that its answer to the question it
>>> was given was "The computation that the input I was given represents,
>>> WILL NOT HALT, when it is run". And EXACTLY That. It doesn't matter
>>> what was written to the tape, as that doesn't have significance to
>>> the API.
>>>
>>
>> It could alternatively cuss you out for trying to cheat using an
>> infinite set of equivalent natural language expressions.
>
> And not be a Halt Decider.
>
>>
>> Boolean True(English, "this sentence is not true")
>> is an incorrect yes/no question.
>>
>
> But "Does the machine represented by this input Halt?", IS a correct
> Yes/No question.
>
> Show me one that doesn't.
>
> Note, The Halting Question is always about a SPECIFIC input computation,
> and thus a specific machine with specific input. The answer doesn't
> depend on who you ask, as it is just about the machine itself.
>
> Thus, to build the input D of the proof, you have had to FIRST define
> the Halt Decider you are going to claim to be correct for all inputs, as
> that is what is needed to convert the "Template" of the proof to an
> actual input.
>
>
>> Tarski was simply too stupid to understand that the Liar Paradox
>> is not a truth bearer and must be rejected as invalid input to
>> any consistent and correct Truth predicate.
>>
>
> Nope, you have proven that you are too stupid to know what he is doing.'
>
> You have admitted that by failing to point out where he does that,
>
> You seem to have a problem with the order of the steps. He shows that
> the existance of a computable Truth predicate leads to impossible
> conclusions, thus it can't exist.
>

On 2/10/2024 2:14 PM, Richard Damon wrote:
> On 2/10/24 1:52 PM, olcott wrote:
>> On 2/10/2024 12:28 PM, Ross Finlayson wrote:
>>> On 02/10/2024 08:18 AM, olcott wrote:
>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to report
>>>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an
>>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of what
>>>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ applied to
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the thing
>>>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>>>>> talk about has a correct answer to it, as every specific input
>>>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>> defined
>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>> So?
>>>>>>>>>>>
>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>>> The issue is not that the most powerful model of computation is
>>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>
>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>>>>> powerful model of computation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>
>>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>>> halt when run.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>
>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents, that is
>>>>>>> Ĥ (Ĥ) will not halt.
>>>>>>>
>>>>>>> Thus you H is just WRONG.
>>>>>>>
>>>>>>
>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>> that can
>>>>>> be expressed using language. This means that embedded_H is not
>>>>>> restricted by typical conventions. embedded_H could output a text
>>>>>> string
>>>>>> swearing at you in English for trying to trick it. This would not
>>>>>> be a
>>>>>> wrong answer.
>>>>>
>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>
>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>
>>>>
>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>> be encoded within language then it ceases to be restricted to Boolean.
>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>
>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>
>>>>>> enum Boolean {
>>>>>>    TRUE,
>>>>>>    FALSE,
>>>>>>    NEITHER
>>>>>> };
>>>>>>
>>>>>> Boolean True(English, "this sentence is not true")
>>>>>> would be required to do this same sort of thing.
>>>>>>
>>>>>>
>>>>>
>>>>> But CAN it? Remember, programs can only do what programs can do, which
>>>>> is based on the instructions they are composed of
>>>>>
>>>>> You are just too stupid to understand this.
>>>>
>>>> It is not that I am stupid it is that you cannot think outside the box
>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>> can communicate in English and understand the meaning of words to the
>>>> same extent that human experts do.
>>>>
>>>
>>> I see you guys are still trying to invalidate each others' deciders.
>>>
>>> In a Comenius language, the Liar: is just the prototype of a fallacy,
>>> sharing as it does properties with "the sputnik of quantification",
>>> "the Russell set", "ORD the order type of ordinals", that when the
>>> self-same Universe of Objects is just truisms the Comenius language,
>>
>> Yes this also gets rid of the issue of undecidability.
>> An expression of language is either true or ~true, thus
>> unprovable from axioms merely mean untrue and cannot
>> mean undecidable.
>
>
>
>>
>> The way that I do this within conventional formal systems
>> is {True, False, Not a truth bearer}.
>
> So, show what you can do in your new Formal System. Remember, you can't
> just assume properties from a different Formal System with different rules.
>
> It has always been you option to decide to start a new set of PO-
> theories, and show what they can do, you just can't add your fundamental
> changes to an existing system after the fact.
>
> See what PO-ZFC generates, or PO-Computation theory does, assuming you
> can actually make them work with the limitations of your system.
>
>>
>> ...14 Every epistemological antinomy can likewise be used for a
>> similar undecidability proof...(Gödel 1931:43)
>>
>> Both Tarski and Gödel did not comprehend that semantically
>> invalid inputs must be rejected as incorrect.
>
> Nope, they did, and they used the fact that we must. You just are too
> stupid to understand what they actually did.
>

On 2/10/24 3:46 PM, olcott wrote:
> On 2/10/2024 2:14 PM, Richard Damon wrote:
>> On 2/10/24 1:52 PM, olcott wrote:
>>> On 2/10/2024 12:28 PM, Ross Finlayson wrote:
>>>> On 02/10/2024 08:18 AM, olcott wrote:
>>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>>> report
>>>>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not
>>>>>>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ
>>>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>>>>>> talk about has a correct answer to it, as every specific
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>>> defined
>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>> So?
>>>>>>>>>>>>
>>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>>> wrong.
>>>>>>>>>>>>
>>>>>>>>>>>>> The issue is not that the most powerful model of
>>>>>>>>>>>>> computation is
>>>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>>>>>> powerful model of computation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>>
>>>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>>>> halt when run.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>>
>>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>>> that is
>>>>>>>> Ĥ (Ĥ) will not halt.
>>>>>>>>
>>>>>>>> Thus you H is just WRONG.
>>>>>>>>
>>>>>>>
>>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>>> that can
>>>>>>> be expressed using language. This means that embedded_H is not
>>>>>>> restricted by typical conventions. embedded_H could output a text
>>>>>>> string
>>>>>>> swearing at you in English for trying to trick it. This would not
>>>>>>> be a
>>>>>>> wrong answer.
>>>>>>
>>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>>
>>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>>
>>>>>
>>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>>> be encoded within language then it ceases to be restricted to Boolean.
>>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>>
>>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>>
>>>>>>> enum Boolean {
>>>>>>>    TRUE,
>>>>>>>    FALSE,
>>>>>>>    NEITHER
>>>>>>> };
>>>>>>>
>>>>>>> Boolean True(English, "this sentence is not true")
>>>>>>> would be required to do this same sort of thing.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>>> which
>>>>>> is based on the instructions they are composed of
>>>>>>
>>>>>> You are just too stupid to understand this.
>>>>>
>>>>> It is not that I am stupid it is that you cannot think outside the box
>>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>>> can communicate in English and understand the meaning of words to the
>>>>> same extent that human experts do.
>>>>>
>>>>
>>>> I see you guys are still trying to invalidate each others' deciders.
>>>>
>>>> In a Comenius language, the Liar: is just the prototype of a fallacy,
>>>> sharing as it does properties with "the sputnik of quantification",
>>>> "the Russell set", "ORD the order type of ordinals", that when the
>>>> self-same Universe of Objects is just truisms the Comenius language,
>>>
>>> Yes this also gets rid of the issue of undecidability.
>>> An expression of language is either true or ~true, thus
>>> unprovable from axioms merely mean untrue and cannot
>>> mean undecidable.
>>
>>
>>
>>>
>>> The way that I do this within conventional formal systems
>>> is {True, False, Not a truth bearer}.
>>
>> So, show what you can do in your new Formal System. Remember, you
>> can't just assume properties from a different Formal System with
>> different rules.
>>
>> It has always been you option to decide to start a new set of PO-
>> theories, and show what they can do, you just can't add your
>> fundamental changes to an existing system after the fact.
>>
>> See what PO-ZFC generates, or PO-Computation theory does, assuming you
>> can actually make them work with the limitations of your system.
>>
>>>
>>> ...14 Every epistemological antinomy can likewise be used for a
>>> similar undecidability proof...(Gödel 1931:43)
>>>
>>> Both Tarski and Gödel did not comprehend that semantically
>>> invalid inputs must be rejected as incorrect.
>>
>> Nope, they did, and they used the fact that we must. You just are too
>> stupid to understand what they actually did.
>>
>
> I just proved that Gödel said that self-contradictory
> expressions can be used "for similar undecidability proof"

On 2/10/24 3:36 PM, olcott wrote:
> On 2/10/2024 2:14 PM, Richard Damon wrote:
>> On 2/10/24 11:53 AM, olcott wrote:
>>> On 2/10/2024 10:35 AM, Richard Damon wrote:
>>>> On 2/10/24 11:18 AM, olcott wrote:
>>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ //
>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   //
>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every
>>>>>>>>>>>>>>>>>>>>>>>>> encoding of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing
>>>>>>>>>>>>>>>>>>>>>>>>> machines such that each one
>>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>>> report its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ
>>>>>>>>>>>>>>>>>>>>>>>> to give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not
>>>>>>>>>>>>>>>>>>>>>>> is an incorrect
>>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>>> what it says.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation
>>>>>>>>>>>>>>>>>>>> described by the input Halt? isn't a
>>>>>>>>>>>>>>>>>>>> self-contradictory question, as it always has a
>>>>>>>>>>>>>>>>>>>> correct answer, the opposite of what H gives (if it
>>>>>>>>>>>>>>>>>>>> gives one).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to
>>>>>>>>>>>>>>>>>>> sixty times before you get it? (it took me twenty
>>>>>>>>>>>>>>>>>>> years to get it this simple)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ
>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of
>>>>>>>>>>>>>>>>>> H that is in it does.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>>> thing that Halting quesiton is about.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that
>>>>>>>>>>>>>>>>>> answers the Halting QUestion which asks the decider
>>>>>>>>>>>>>>>>>> about the SPECIFIC COMPUTATION (a specific
>>>>>>>>>>>>>>>>>> program/data) that the input describes.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct
>>>>>>>>>>>>>>>> answer, just not the one the decider gave.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set
>>>>>>>>>>>>>> you talk about has a correct answer to it, as every
>>>>>>>>>>>>>> specific input describes a Halting Computation or not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>>> defined
>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>> So?
>>>>>>>>>>>>
>>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>>> wrong.
>>>>>>>>>>>>
>>>>>>>>>>>>> The issue is not that the most powerful model of
>>>>>>>>>>>>> computation is
>>>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>>> reasons for wanting an answer, can not be computed by this
>>>>>>>>>>>> most powerful model of computation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>>
>>>>>>>>>> No, it is asking if the computation described by the input
>>>>>>>>>> will halt when run.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>>
>>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes
>>>>>>>> to qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>>> that is Ĥ (Ĥ) will not halt.
>>>>>>>>
>>>>>>>> Thus you H is just WRONG.
>>>>>>>>
>>>>>>>
>>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>>> that can
>>>>>>> be expressed using language. This means that embedded_H is not
>>>>>>> restricted by typical conventions. embedded_H could output a text
>>>>>>> string
>>>>>>> swearing at you in English for trying to trick it. This would not
>>>>>>> be a
>>>>>>> wrong answer.
>>>>>>
>>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>>
>>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>>
>>>>>
>>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>>> be encoded within language then it ceases to be restricted to Boolean.
>>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>>
>>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>>
>>>>>>> enum Boolean {
>>>>>>>    TRUE,
>>>>>>>    FALSE,
>>>>>>>    NEITHER
>>>>>>> };
>>>>>>>
>>>>>>> Boolean True(English, "this sentence is not true")
>>>>>>> would be required to do this same sort of thing.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>>> which is based on the instructions they are composed of
>>>>>>
>>>>>> You are just too stupid to understand this.
>>>>>
>>>>> It is not that I am stupid it is that you cannot think outside the box
>>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>>> can communicate in English and understand the meaning of words to the
>>>>> same extent that human experts do.
>>>>>
>>>>
>>>> You don't understand that your program must follow the rules of a
>>>> program!
>>>>
>>>
>>> It need not follow any arbitrary conventions.
>>>
>>>> IF you think what you claim is possible, DO IT.
>>>>
>>>> Remember though, that H has a defined "API", it is to give it's
>>>> answer in a specific way, and each option has a defined meaning.
>>>>
>>>
>>> The API could output its halt status determination using an
>>> infinite set of equivalent natural language expressions.
>>>
>>>> Perhaps it could write a message in English on its tape, but then
>>>> going to Qn, it is clearly stating that its answer to the question
>>>> it was given was "The computation that the input I was given
>>>> represents, WILL NOT HALT, when it is run". And EXACTLY That. It
>>>> doesn't matter what was written to the tape, as that doesn't have
>>>> significance to the API.
>>>>
>>>
>>> It could alternatively cuss you out for trying to cheat using an
>>> infinite set of equivalent natural language expressions.
>>
>> And not be a Halt Decider.
>>
>>>
>>> Boolean True(English, "this sentence is not true")
>>> is an incorrect yes/no question.
>>>
>>
>> But "Does the machine represented by this input Halt?", IS a correct
>> Yes/No question.
>>
>> Show me one that doesn't.
>>
>> Note, The Halting Question is always about a SPECIFIC input
>> computation, and thus a specific machine with specific input. The
>> answer doesn't depend on who you ask, as it is just about the machine
>> itself.
>>
>> Thus, to build the input D of the proof, you have had to FIRST define
>> the Halt Decider you are going to claim to be correct for all inputs,
>> as that is what is needed to convert the "Template" of the proof to an
>> actual input.
>>
>>
>>> Tarski was simply too stupid to understand that the Liar Paradox
>>> is not a truth bearer and must be rejected as invalid input to
>>> any consistent and correct Truth predicate.
>>>
>>
>> Nope, you have proven that you are too stupid to know what he is doing.'
>>
>> You have admitted that by failing to point out where he does that,
>>
>> You seem to have a problem with the order of the steps. He shows that
>> the existance of a computable Truth predicate leads to impossible
>> conclusions, thus it can't exist.
>>
>
> You said that you understand that the Liar Paradox is
> neither true nor false. This entails that you understand
> Boolean True(English, "this sentence is not true")
> is an incorrect question.
>
> *If Tarski did not understand that then Tarski must be wrong*
>

On 2/10/2024 3:40 PM, Richard Damon wrote:
> On 2/10/24 3:46 PM, olcott wrote:
>> On 2/10/2024 2:14 PM, Richard Damon wrote:
>>> On 2/10/24 1:52 PM, olcott wrote:
>>>> On 2/10/2024 12:28 PM, Ross Finlayson wrote:
>>>>> On 02/10/2024 08:18 AM, olcott wrote:
>>>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every
>>>>>>>>>>>>>>>>>>>>>>>>>> encoding
>>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing
>>>>>>>>>>>>>>>>>>>>>>>>>> machines
>>>>>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>>>> report
>>>>>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not
>>>>>>>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong
>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation
>>>>>>>>>>>>>>>>>>>>> described
>>>>>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory
>>>>>>>>>>>>>>>>>>>>> question,
>>>>>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of
>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to
>>>>>>>>>>>>>>>>>>>> get
>>>>>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ
>>>>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that
>>>>>>>>>>>>>>>>>>> answers
>>>>>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no
>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct
>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>>>> every value that each embedded_H returns for the
>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set
>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>> talk about has a correct answer to it, as every specific
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> So?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The issue is not that the most powerful model of
>>>>>>>>>>>>>> computation is
>>>>>>>>>>>>>> too weak. The issue is that an input was intentionally
>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>>>> reasons for wanting an answer, can not be computed by this
>>>>>>>>>>>>> most
>>>>>>>>>>>>> powerful model of computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>>>
>>>>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>>>>> halt when run.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>>>
>>>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>>>> that is
>>>>>>>>> Ĥ (Ĥ) will not halt.
>>>>>>>>>
>>>>>>>>> Thus you H is just WRONG.
>>>>>>>>>
>>>>>>>>
>>>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>>>> that can
>>>>>>>> be expressed using language. This means that embedded_H is not
>>>>>>>> restricted by typical conventions. embedded_H could output a
>>>>>>>> text string
>>>>>>>> swearing at you in English for trying to trick it. This would
>>>>>>>> not be a
>>>>>>>> wrong answer.
>>>>>>>
>>>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>>>
>>>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>>>
>>>>>>
>>>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>>>> be encoded within language then it ceases to be restricted to
>>>>>> Boolean.
>>>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>>>
>>>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>>>
>>>>>>>> enum Boolean {
>>>>>>>>    TRUE,
>>>>>>>>    FALSE,
>>>>>>>>    NEITHER
>>>>>>>> };
>>>>>>>>
>>>>>>>> Boolean True(English, "this sentence is not true")
>>>>>>>> would be required to do this same sort of thing.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>>>> which
>>>>>>> is based on the instructions they are composed of
>>>>>>>
>>>>>>> You are just too stupid to understand this.
>>>>>>
>>>>>> It is not that I am stupid it is that you cannot think outside the
>>>>>> box
>>>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>>>> can communicate in English and understand the meaning of words to the
>>>>>> same extent that human experts do.
>>>>>>
>>>>>
>>>>> I see you guys are still trying to invalidate each others' deciders.
>>>>>
>>>>> In a Comenius language, the Liar: is just the prototype of a fallacy,
>>>>> sharing as it does properties with "the sputnik of quantification",
>>>>> "the Russell set", "ORD the order type of ordinals", that when the
>>>>> self-same Universe of Objects is just truisms the Comenius language,
>>>>
>>>> Yes this also gets rid of the issue of undecidability.
>>>> An expression of language is either true or ~true, thus
>>>> unprovable from axioms merely mean untrue and cannot
>>>> mean undecidable.
>>>
>>>
>>>
>>>>
>>>> The way that I do this within conventional formal systems
>>>> is {True, False, Not a truth bearer}.
>>>
>>> So, show what you can do in your new Formal System. Remember, you
>>> can't just assume properties from a different Formal System with
>>> different rules.
>>>
>>> It has always been you option to decide to start a new set of PO-
>>> theories, and show what they can do, you just can't add your
>>> fundamental changes to an existing system after the fact.
>>>
>>> See what PO-ZFC generates, or PO-Computation theory does, assuming
>>> you can actually make them work with the limitations of your system.
>>>
>>>>
>>>> ...14 Every epistemological antinomy can likewise be used for a
>>>> similar undecidability proof...(Gödel 1931:43)
>>>>
>>>> Both Tarski and Gödel did not comprehend that semantically
>>>> invalid inputs must be rejected as incorrect.
>>>
>>> Nope, they did, and they used the fact that we must. You just are too
>>> stupid to understand what they actually did.
>>>
>>
>> I just proved that Gödel said that self-contradictory
>> expressions can be used "for similar undecidability proof"
>
> Yep, but you just don't understand what he means by that.
>
>>
>> That you understand that the Liar Paradox is a
>> self-contradictory expression having no truth value
>> means that you understand that it cannot be proven
>> true or false.
>>
>
> Right, and so did Godel.
>

On 2/10/2024 3:40 PM, Richard Damon wrote:
> On 2/10/24 3:36 PM, olcott wrote:
>> On 2/10/2024 2:14 PM, Richard Damon wrote:
>>> On 2/10/24 11:53 AM, olcott wrote:
>>>> On 2/10/2024 10:35 AM, Richard Damon wrote:
>>>>> On 2/10/24 11:18 AM, olcott wrote:
>>>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ //
>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   //
>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every
>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing
>>>>>>>>>>>>>>>>>>>>>>>>>> machines such that each one
>>>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>>>> report its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ
>>>>>>>>>>>>>>>>>>>>>>>>> to give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not
>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect
>>>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong
>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>>>> what it says.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any
>>>>>>>>>>>>>>>>>>>>>> correct answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation
>>>>>>>>>>>>>>>>>>>>> described by the input Halt? isn't a
>>>>>>>>>>>>>>>>>>>>> self-contradictory question, as it always has a
>>>>>>>>>>>>>>>>>>>>> correct answer, the opposite of what H gives (if it
>>>>>>>>>>>>>>>>>>>>> gives one).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to
>>>>>>>>>>>>>>>>>>>> sixty times before you get it? (it took me twenty
>>>>>>>>>>>>>>>>>>>> years to get it this simple)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy
>>>>>>>>>>>>>>>>>>>> and Ĥ.qn are the wrong answer for every possible Ĥ
>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of
>>>>>>>>>>>>>>>>>>> H that is in it does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>>>> thing that Halting quesiton is about.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that
>>>>>>>>>>>>>>>>>>> answers the Halting QUestion which asks the decider
>>>>>>>>>>>>>>>>>>> about the SPECIFIC COMPUTATION (a specific
>>>>>>>>>>>>>>>>>>> program/data) that the input describes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no
>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct
>>>>>>>>>>>>>>>>> answer, just not the one the decider gave.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>>>> every value that each embedded_H returns for the
>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a
>>>>>>>>>>>>>>>> self-contradictory question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set
>>>>>>>>>>>>>>> you talk about has a correct answer to it, as every
>>>>>>>>>>>>>>> specific input describes a Halting Computation or not.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> So?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The issue is not that the most powerful model of
>>>>>>>>>>>>>> computation is
>>>>>>>>>>>>>> too weak. The issue is that an input was intentionally
>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it shows that the simple problem, for which we have
>>>>>>>>>>>>> good reasons for wanting an answer, can not be computed by
>>>>>>>>>>>>> this most powerful model of computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>>>
>>>>>>>>>>> No, it is asking if the computation described by the input
>>>>>>>>>>> will halt when run.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>>>
>>>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes
>>>>>>>>> to qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>>>> that is Ĥ (Ĥ) will not halt.
>>>>>>>>>
>>>>>>>>> Thus you H is just WRONG.
>>>>>>>>>
>>>>>>>>
>>>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>>>> that can
>>>>>>>> be expressed using language. This means that embedded_H is not
>>>>>>>> restricted by typical conventions. embedded_H could output a
>>>>>>>> text string
>>>>>>>> swearing at you in English for trying to trick it. This would
>>>>>>>> not be a
>>>>>>>> wrong answer.
>>>>>>>
>>>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>>>
>>>>>>> Since Embedded_H is (at least by your claims) an exact copy of
>>>>>>> the Turing Machine H, it can only do what a Turing Machine can do.
>>>>>>>
>>>>>>
>>>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>>>> be encoded within language then it ceases to be restricted to
>>>>>> Boolean.
>>>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>>>
>>>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>>>
>>>>>>>> enum Boolean {
>>>>>>>>    TRUE,
>>>>>>>>    FALSE,
>>>>>>>>    NEITHER
>>>>>>>> };
>>>>>>>>
>>>>>>>> Boolean True(English, "this sentence is not true")
>>>>>>>> would be required to do this same sort of thing.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>>>> which is based on the instructions they are composed of
>>>>>>>
>>>>>>> You are just too stupid to understand this.
>>>>>>
>>>>>> It is not that I am stupid it is that you cannot think outside the
>>>>>> box
>>>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>>>> can communicate in English and understand the meaning of words to the
>>>>>> same extent that human experts do.
>>>>>>
>>>>>
>>>>> You don't understand that your program must follow the rules of a
>>>>> program!
>>>>>
>>>>
>>>> It need not follow any arbitrary conventions.
>>>>
>>>>> IF you think what you claim is possible, DO IT.
>>>>>
>>>>> Remember though, that H has a defined "API", it is to give it's
>>>>> answer in a specific way, and each option has a defined meaning.
>>>>>
>>>>
>>>> The API could output its halt status determination using an
>>>> infinite set of equivalent natural language expressions.
>>>>
>>>>> Perhaps it could write a message in English on its tape, but then
>>>>> going to Qn, it is clearly stating that its answer to the question
>>>>> it was given was "The computation that the input I was given
>>>>> represents, WILL NOT HALT, when it is run". And EXACTLY That. It
>>>>> doesn't matter what was written to the tape, as that doesn't have
>>>>> significance to the API.
>>>>>
>>>>
>>>> It could alternatively cuss you out for trying to cheat using an
>>>> infinite set of equivalent natural language expressions.
>>>
>>> And not be a Halt Decider.
>>>
>>>>
>>>> Boolean True(English, "this sentence is not true")
>>>> is an incorrect yes/no question.
>>>>
>>>
>>> But "Does the machine represented by this input Halt?", IS a correct
>>> Yes/No question.
>>>
>>> Show me one that doesn't.
>>>
>>> Note, The Halting Question is always about a SPECIFIC input
>>> computation, and thus a specific machine with specific input. The
>>> answer doesn't depend on who you ask, as it is just about the machine
>>> itself.
>>>
>>> Thus, to build the input D of the proof, you have had to FIRST define
>>> the Halt Decider you are going to claim to be correct for all inputs,
>>> as that is what is needed to convert the "Template" of the proof to
>>> an actual input.
>>>
>>>
>>>> Tarski was simply too stupid to understand that the Liar Paradox
>>>> is not a truth bearer and must be rejected as invalid input to
>>>> any consistent and correct Truth predicate.
>>>>
>>>
>>> Nope, you have proven that you are too stupid to know what he is doing.'
>>>
>>> You have admitted that by failing to point out where he does that,
>>>
>>> You seem to have a problem with the order of the steps. He shows that
>>> the existance of a computable Truth predicate leads to impossible
>>> conclusions, thus it can't exist.
>>>
>>
>> You said that you understand that the Liar Paradox is
>> neither true nor false. This entails that you understand
>> Boolean True(English, "this sentence is not true")
>> is an incorrect question.
>>
>> *If Tarski did not understand that then Tarski must be wrong*
>>
>
> In other words, you still don't understand what you are talking about.
>
> True(English, ...) isn't a predicate in "Formal Logic", as "English" is
> not a Frmal Logic system, so you are just proving your stupidity.

On 2/10/24 5:11 PM, olcott wrote:
> On 2/10/2024 3:40 PM, Richard Damon wrote:

>> In other words, you still don't understand what you are talking about.
>>
>> True(English, ...) isn't a predicate in "Formal Logic", as "English"
>> is not a Frmal Logic system, so you are just proving your stupidity.
>
> Yet it s well known that English can be formalized correctly
> with Montague grammar. I wrote it in English because it is
> conventional to always formalize self-reference incorrectly.

In other words, you have absolutely no idea what a "Formal Logic System"
actually is.

I'm not sure you even know what a logic system is, let alone what it
means to be formalized.

>
> The only way around this is to create a formal system that
> does formalize self-reference correctly.
>
> It doesn't really need to actually be formalized. People
> can correctly determine that the English Liar Paradox
> is neither true nor false, thus can infer that a correct
> and consistent True predicate must reject it.
>

If it isn't formalized, you are doing formal logic.

On 2/10/24 5:05 PM, olcott wrote:
> On 2/10/2024 3:40 PM, Richard Damon wrote:
>> On 2/10/24 3:46 PM, olcott wrote:

>>> That you understand that the Liar Paradox is a
>>> self-contradictory expression having no truth value
>>> means that you understand that it cannot be proven
>>> true or false.
>>>
>>
>> Right, and so did Godel.
>>
>
> Boolean True(English, "this sentence is not true")
> is an incorrect yes/no question.
>
> Thus when we assume that I characterized Tarski correctly then
> his claim that the above proves that a correct and consistent
> Truth predicate cannot exist would be woefully incorrect.
>

Why should we assume that? You show a remrkable talent for trying to
assume things that are incorrect, or even impossible. You have shown you
don't understand what a formal logic system is, so you have absolutely
no basis to be talking about what he is doing.

Your Liar's paradox is that you just blatently lie, but don't see that
you are doing it because the lies are pathological.

On 02/10/2024 12:46 PM, olcott wrote:
> On 2/10/2024 2:14 PM, Richard Damon wrote:
>> On 2/10/24 1:52 PM, olcott wrote:
>>> On 2/10/2024 12:28 PM, Ross Finlayson wrote:
>>>> On 02/10/2024 08:18 AM, olcott wrote:
>>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // wrong
>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every encoding
>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing machines
>>>>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>>> report
>>>>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not
>>>>>>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation described
>>>>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory question,
>>>>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of what
>>>>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to get
>>>>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ
>>>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that answers
>>>>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no correct
>>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct answer,
>>>>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set you
>>>>>>>>>>>>>> talk about has a correct answer to it, as every specific
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>>> defined
>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>> So?
>>>>>>>>>>>>
>>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>>> wrong.
>>>>>>>>>>>>
>>>>>>>>>>>>> The issue is not that the most powerful model of
>>>>>>>>>>>>> computation is
>>>>>>>>>>>>> too weak. The issue is that an input was intentionally defined
>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>>> reasons for wanting an answer, can not be computed by this most
>>>>>>>>>>>> powerful model of computation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>>
>>>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>>>> halt when run.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>>
>>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>>> that is
>>>>>>>> Ĥ (Ĥ) will not halt.
>>>>>>>>
>>>>>>>> Thus you H is just WRONG.
>>>>>>>>
>>>>>>>
>>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>>> that can
>>>>>>> be expressed using language. This means that embedded_H is not
>>>>>>> restricted by typical conventions. embedded_H could output a text
>>>>>>> string
>>>>>>> swearing at you in English for trying to trick it. This would not
>>>>>>> be a
>>>>>>> wrong answer.
>>>>>>
>>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>>
>>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>>
>>>>>
>>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>>> be encoded within language then it ceases to be restricted to Boolean.
>>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>>
>>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>>
>>>>>>> enum Boolean {
>>>>>>> TRUE,
>>>>>>> FALSE,
>>>>>>> NEITHER
>>>>>>> };
>>>>>>>
>>>>>>> Boolean True(English, "this sentence is not true")
>>>>>>> would be required to do this same sort of thing.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>>> which
>>>>>> is based on the instructions they are composed of
>>>>>>
>>>>>> You are just too stupid to understand this.
>>>>>
>>>>> It is not that I am stupid it is that you cannot think outside the box
>>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>>> can communicate in English and understand the meaning of words to the
>>>>> same extent that human experts do.
>>>>>
>>>>
>>>> I see you guys are still trying to invalidate each others' deciders.
>>>>
>>>> In a Comenius language, the Liar: is just the prototype of a fallacy,
>>>> sharing as it does properties with "the sputnik of quantification",
>>>> "the Russell set", "ORD the order type of ordinals", that when the
>>>> self-same Universe of Objects is just truisms the Comenius language,
>>>
>>> Yes this also gets rid of the issue of undecidability.
>>> An expression of language is either true or ~true, thus
>>> unprovable from axioms merely mean untrue and cannot
>>> mean undecidable.
>>
>>
>>
>>>
>>> The way that I do this within conventional formal systems
>>> is {True, False, Not a truth bearer}.
>>
>> So, show what you can do in your new Formal System. Remember, you
>> can't just assume properties from a different Formal System with
>> different rules.
>>
>> It has always been you option to decide to start a new set of PO-
>> theories, and show what they can do, you just can't add your
>> fundamental changes to an existing system after the fact.
>>
>> See what PO-ZFC generates, or PO-Computation theory does, assuming you
>> can actually make them work with the limitations of your system.
>>
>>>
>>> ...14 Every epistemological antinomy can likewise be used for a
>>> similar undecidability proof...(Gödel 1931:43)
>>>
>>> Both Tarski and Gödel did not comprehend that semantically
>>> invalid inputs must be rejected as incorrect.
>>
>> Nope, they did, and they used the fact that we must. You just are too
>> stupid to understand what they actually did.
>>
>
> I just proved that Gödel said that self-contradictory
> expressions can be used "for similar undecidability proof"
>
> That you understand that the Liar Paradox is a
> self-contradictory expression having no truth value
> means that you understand that it cannot be proven
> true or false.
>
>
>>>
>>> Instead Tarski concluded that a correct and consistent
>>> truth predicate cannot exist on this basis:
>>> Boolean True(English, "this sentence is not true")
>>
>> Nope. Note, "English" is not a proper "Formal System".
>>
>> Your lack of understanding that shows you ignorant you are.
>
> Not at all the English does have a formal isomorphism.
>
>
>>>
>>>> then the Liar is just the prototype of a fallacy, there isn't a
>>>> paradox so you can get rid of Ex Falso Quodlibet for Ex Falso Nihilum,
>>>> and then otherwise get back into hard problems and approximations
>>>> thereof, for which there are all manners of static analysis to
>>>> determine both for distributions what are optimal algorithms,
>>>> and, for what distributions are pathological algorithms.
>>>>
>>>> Then there's the fun part with "sequences that converge slowly",
>>>> "anti-inductive results", "the super-task", "deductive closures
>>>> in complementary duals", "completions in universals and particulars".
>>>>
>>>>
>>>> "Comte's Boole's Russell's Whitehead's logical positivism's
>>>> 'classical' logic is really only 'classical _quasi-modal_ logic'."
>>>>
>>>> It's neither modal nor monotone, looking at it either way.
>>>>
>>>>
>>>
>>
>

On 2/10/2024 8:13 PM, Ross Finlayson wrote:
> On 02/10/2024 12:46 PM, olcott wrote:
>> On 2/10/2024 2:14 PM, Richard Damon wrote:
>>> On 2/10/24 1:52 PM, olcott wrote:
>>>> On 2/10/2024 12:28 PM, Ross Finlayson wrote:
>>>>> On 02/10/2024 08:18 AM, olcott wrote:
>>>>>> On 2/10/2024 9:29 AM, Richard Damon wrote:
>>>>>>> On 2/10/24 10:06 AM, olcott wrote:
>>>>>>>> On 2/10/2024 7:35 AM, Richard Damon wrote:
>>>>>>>>> On 2/10/24 12:33 AM, olcott wrote:
>>>>>>>>>> On 2/9/2024 11:15 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/24 11:24 PM, olcott wrote:
>>>>>>>>>>>> On 2/9/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/9/24 9:50 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/9/2024 6:05 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/9/24 12:22 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/24 10:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> answer
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The above pair of templates specify every
>>>>>>>>>>>>>>>>>>>>>>>>>> encoding
>>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ that can
>>>>>>>>>>>>>>>>>>>>>>>>>> possibly exist, an infinite set of Turing
>>>>>>>>>>>>>>>>>>>>>>>>>> machines
>>>>>>>>>>>>>>>>>>>>>>>>>> such that each one
>>>>>>>>>>>>>>>>>>>>>>>>>> gets the wrong answer when it is required to
>>>>>>>>>>>>>>>>>>>>>>>>>> report
>>>>>>>>>>>>>>>>>>>>>>>>>> its own halt status.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This proves that it is impossible to for any Ĥ to
>>>>>>>>>>>>>>>>>>>>>>>>> give the right answer on all inputs.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It proves that asking Ĥ whether it halts or not
>>>>>>>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>>>>> question where both yes and no are the wrong
>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, it proves the right answer is the opposite of
>>>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>>>> it says.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *This seems to be over your head*
>>>>>>>>>>>>>>>>>>>>>> A self-contradictory question never has any correct
>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So the Halting Question, does the computation
>>>>>>>>>>>>>>>>>>>>> described
>>>>>>>>>>>>>>>>>>>>> by the input Halt? isn't a self-contradictory
>>>>>>>>>>>>>>>>>>>>> question,
>>>>>>>>>>>>>>>>>>>>> as it always has a correct answer, the opposite of
>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>> H gives (if it gives one).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus, your premise is false.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Maybe you need to carefully reread this fifty to sixty
>>>>>>>>>>>>>>>>>>>> times before you get it? (it took me twenty years to
>>>>>>>>>>>>>>>>>>>> get
>>>>>>>>>>>>>>>>>>>> it this simple)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and
>>>>>>>>>>>>>>>>>>>> Ĥ.qn are the wrong answer for every possible Ĥ
>>>>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But Ĥ doesn't need to report on anything, the copy of H
>>>>>>>>>>>>>>>>>>> that is in it does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that every possible element of an
>>>>>>>>>>>>>>>>>>>> infinite set is more than one element?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, so the set isn't a specific input, so not the
>>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>>> that Halting quesiton is about.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The Haltig problem is about making a decider that
>>>>>>>>>>>>>>>>>>> answers
>>>>>>>>>>>>>>>>>>> the Halting QUestion which asks the decider about the
>>>>>>>>>>>>>>>>>>> SPECIFIC COMPUTATION (a specific program/data) that the
>>>>>>>>>>>>>>>>>>> input describes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not about "sets" of Decider / Inputs
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When an infinite set of decider/input pairs has no
>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>> answer then the question is rigged.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that EVERY element of that set had a correct
>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>> just not the one the decider gave.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to
>>>>>>>>>>>>>>>> contradict
>>>>>>>>>>>>>>>> every value that each embedded_H returns for the infinite
>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>> every Ĥ that can possibly exist then each and every
>>>>>>>>>>>>>>>> element of
>>>>>>>>>>>>>>>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory
>>>>>>>>>>>>>>>> question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, YOUR POOP question, is self-contradictory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Halting Question is not, as EVERY element of that set
>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>> talk about has a correct answer to it, as every specific
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> describes a Halting Computation or not.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When every possible Ĥ of the infinite set of Ĥ is applied to
>>>>>>>>>>>>>> its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally
>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> So?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, every possible Ĥ means every possible H, so all H are
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The issue is not that the most powerful model of
>>>>>>>>>>>>>> computation is
>>>>>>>>>>>>>> too weak. The issue is that an input was intentionally
>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>> to be self-contradictory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it shows that the simple problem, for which we have good
>>>>>>>>>>>>> reasons for wanting an answer, can not be computed by this
>>>>>>>>>>>>> most
>>>>>>>>>>>>> powerful model of computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is asking Ĥ:
>>>>>>>>>>>> Do you halt on your own Turing Machine Description?
>>>>>>>>>>>
>>>>>>>>>>> No, it is asking if the computation described by the input will
>>>>>>>>>>> halt when run.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Linz and I have been referring to the actual computation of
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ with no simulators involved.
>>>>>>>>>
>>>>>>>>> Right, and since your Ĥ (Ĥ) will Halt since your H (Ĥ) (Ĥ) goes to
>>>>>>>>> qn to say the computation that its input (Ĥ) (Ĥ) represents,
>>>>>>>>> that is
>>>>>>>>> Ĥ (Ĥ) will not halt.
>>>>>>>>>
>>>>>>>>> Thus you H is just WRONG.
>>>>>>>>>
>>>>>>>>
>>>>>>>> embedded_H could be encoded with every detail all of knowledge
>>>>>>>> that can
>>>>>>>> be expressed using language. This means that embedded_H is not
>>>>>>>> restricted by typical conventions. embedded_H could output a text
>>>>>>>> string
>>>>>>>> swearing at you in English for trying to trick it. This would not
>>>>>>>> be a
>>>>>>>> wrong answer.
>>>>>>>
>>>>>>> Embedded H is restricted to only be able to do what is computable.
>>>>>>>
>>>>>>> Since Embedded_H is (at least by your claims) an exact copy of the
>>>>>>> Turing Machine H, it can only do what a Turing Machine can do.
>>>>>>>
>>>>>>
>>>>>> When Embedded_H has encoded within it all of human knowledge that can
>>>>>> be encoded within language then it ceases to be restricted to
>>>>>> Boolean.
>>>>>> This enables Embedded_H to do anything that a human mind can do.
>>>>>>
>>>>>>> So, it CAN'T do what you claim, so you are a LIAR.
>>>>>>>>
>>>>>>>> enum Boolean {
>>>>>>>>    TRUE,
>>>>>>>>    FALSE,
>>>>>>>>    NEITHER
>>>>>>>> };
>>>>>>>>
>>>>>>>> Boolean True(English, "this sentence is not true")
>>>>>>>> would be required to do this same sort of thing.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> But CAN it? Remember, programs can only do what programs can do,
>>>>>>> which
>>>>>>> is based on the instructions they are composed of
>>>>>>>
>>>>>>> You are just too stupid to understand this.
>>>>>>
>>>>>> It is not that I am stupid it is that you cannot think outside the
>>>>>> box
>>>>>> of conventional wisdom. There is nothing impossible about a TM that
>>>>>> can communicate in English and understand the meaning of words to the
>>>>>> same extent that human experts do.
>>>>>>
>>>>>
>>>>> I see you guys are still trying to invalidate each others' deciders.
>>>>>
>>>>> In a Comenius language, the Liar: is just the prototype of a fallacy,
>>>>> sharing as it does properties with "the sputnik of quantification",
>>>>> "the Russell set", "ORD the order type of ordinals", that when the
>>>>> self-same Universe of Objects is just truisms the Comenius language,
>>>>
>>>> Yes this also gets rid of the issue of undecidability.
>>>> An expression of language is either true or ~true, thus
>>>> unprovable from axioms merely mean untrue and cannot
>>>> mean undecidable.
>>>
>>>
>>>
>>>>
>>>> The way that I do this within conventional formal systems
>>>> is {True, False, Not a truth bearer}.
>>>
>>> So, show what you can do in your new Formal System. Remember, you
>>> can't just assume properties from a different Formal System with
>>> different rules.
>>>
>>> It has always been you option to decide to start a new set of PO-
>>> theories, and show what they can do, you just can't add your
>>> fundamental changes to an existing system after the fact.
>>>
>>> See what PO-ZFC generates, or PO-Computation theory does, assuming you
>>> can actually make them work with the limitations of your system.
>>>
>>>>
>>>> ...14 Every epistemological antinomy can likewise be used for a
>>>> similar undecidability proof...(Gödel 1931:43)
>>>>
>>>> Both Tarski and Gödel did not comprehend that semantically
>>>> invalid inputs must be rejected as incorrect.
>>>
>>> Nope, they did, and they used the fact that we must. You just are too
>>> stupid to understand what they actually did.
>>>
>>
>> I just proved that Gödel said that self-contradictory
>> expressions can be used "for similar undecidability proof"
>>
>> That you understand that the Liar Paradox is a
>> self-contradictory expression having no truth value
>> means that you understand that it cannot be proven
>> true or false.
>>
>>
>>>>
>>>> Instead Tarski concluded that a correct and consistent
>>>> truth predicate cannot exist on this basis:
>>>> Boolean True(English, "this sentence is not true")
>>>
>>> Nope. Note, "English" is not a proper "Formal System".
>>>
>>> Your lack of understanding that shows you ignorant you are.
>>
>> Not at all the English does have a formal isomorphism.
>>
>>
>>>>
>>>>> then the Liar is just the prototype of a fallacy, there isn't a
>>>>> paradox so you can get rid of Ex Falso Quodlibet for Ex Falso Nihilum,
>>>>> and then otherwise get back into hard problems and approximations
>>>>> thereof, for which there are all manners of static analysis to
>>>>> determine both for distributions what are optimal algorithms,
>>>>> and, for what distributions are pathological algorithms.
>>>>>
>>>>> Then there's the fun part with "sequences that converge slowly",
>>>>> "anti-inductive results", "the super-task", "deductive closures
>>>>> in complementary duals", "completions in universals and particulars".
>>>>>
>>>>>
>>>>> "Comte's Boole's Russell's Whitehead's logical positivism's
>>>>> 'classical' logic is really only 'classical _quasi-modal_ logic'."
>>>>>
>>>>> It's neither modal nor monotone, looking at it either way.
>>>>>
>>>>>
>>>>
>>>
>>
>
> There's Montague, he says English can be formal.
>