On 2/9/2022 10:43 PM, Richard Damon wrote:
> On 2/9/22 11:06 PM, olcott wrote:
>> On 2/9/2022 9:52 PM, Richard Damon wrote:
>>> On 2/9/22 10:31 PM, olcott wrote:
>>>> On 2/9/2022 9:25 PM, Richard Damon wrote:
>>>>> On 2/9/22 10:07 PM, olcott wrote:
>>>>>> On 2/9/2022 8:09 PM, Richard Damon wrote:
>>>>>>> On 2/9/22 8:45 PM, olcott wrote:
>>>>>>>> On 2/9/2022 4:11 PM, Richard Damon wrote:
>>>>>>>>> On 2/9/22 4:27 PM, olcott wrote:
>>>>>>>>>> On 2/9/2022 3:14 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/22 4:03 PM, olcott wrote:
>>>>>>>>>>>> On 2/9/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 2/9/22 2:37 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/9/2022 1:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/9/22 1:56 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 2/9/22 1:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of matching
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state. Otherwise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does not cover
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches an "infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had previously been
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is undecidable. That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all that I need to refute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either halts or matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem my program must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all knowing. To refute the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs I merely need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact that if H applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then by construction H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> goes to H^.Qn, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must only go to H,Qn if the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents will never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They you also don't seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents IS H^ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved the thing you claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> youhave, but only that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have amassed an amazing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pile of unsound logic based
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on wrong definitions that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have hoodwinked yourself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into thinking you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't actually understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough computer science to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong and never will because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough Computation Theory to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory, using
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders are deciders they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their input finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to an accept or reject state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not their correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input could ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correcty simulted' is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not enough steps for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by embedded_H to transition to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H meets the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps and doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state, then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite pattern in the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H will never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn in any number of steps,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which proves that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly meet the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine will halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whenever it enters a final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you show that does not halt is H,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so H can not be a decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates three iterations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation to match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to match this pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number, the H^ that is using it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will Halt,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of its inputs as if its was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a guard assigned to watch the front.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If someone comes in the back door
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (non-inputs) embedded_H is not even
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to pay attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> is not the behavior of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> you are lying about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H cannot possibly ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state of ⟨Ĥ⟩.qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing in the universe can possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contradict the fact that the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations. If God himself said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise then God himself would be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and goes to H.Qn, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT simulation of its input (that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> done by a REAL UTM) will show that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All you have proven is that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort, and thus doesn't go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, and thus fails to be a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider, then H^ applied to <H^> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that aborts its simulation is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correct' simulation. By the definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Computation Theory, this is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true. If you think it is, it just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that you don't understand the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> field.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then we know that we have a cat.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cat but think you do then you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong. If H aborts its simulation, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't a UTM and doesn't 'correctly'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations that cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state then we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that we have a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H -> H.Qn then the pattern WILL reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state proves just proves that if H is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, which don't abort, then H^ will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H is still wrong for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not answering. If H does abort, then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hasn't proven anything, and it has been
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven that it is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are either not bright enough to get
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this or dishonest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to computer scientists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguing by insults, classic Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logical fallicy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fundamentally you seem to lack the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intellectual capacity to understand what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> am saying. This is proven on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that what I am saying can be verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true entirely on the basis of the meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that it has been shown that you keep
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on using the WRONG definitions of the words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, a UTM EXACTLY repoduces the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of its input (so if it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, so will the UTM). Also you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> think that there can be a 'Correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation' by something that is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actully a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Care to show anywhere where your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> misdefinitions are support in the field fo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That just PROVES that you aren't actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> working on the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertions, maybe because you just don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know the field, so don't have any idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is legal or not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also note, you keep talking about needing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'Computer Scientists' to understand, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is really incorrect, you need to be able
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to explain it to someone who understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory, which is a fairly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specialized branch of Mathematics. Yes,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is part of the foundation of Computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Science, but isn't the sort of thing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a normal Computer Scientist will deal
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with day to day.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I need someone to analyze what I am saying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the deep meaning of what I am saying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead of mere rote memorized meanings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from textbooks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you need to learn that words have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISE meanings, and you aren't allowed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change them, no mwtter how much it 'makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sense' to do so.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key mistake that my reviewers are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> making is that they believe that the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider is supposed to evaluate its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of some proxy for the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of this actual input rather than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Just proves you aren't working on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, as the DEFINITION of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problems says that it is, because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you don't actually understand the meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of 'actual behavior'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qy IFF M applied to w halts, and to H,Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if M applied to w will never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you are supposed to report when Bill
>>>>>>>>>>>>>>>>>>>>>>>>>>>> arrives at your house and Sam arrives at you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> house and you really really believe that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sam's arrival is a valid proxy for Bill's
>>>>>>>>>>>>>>>>>>>>>>>>>>>> arrival then when I ask you did Bill arrive
>>>>>>>>>>>>>>>>>>>>>>>>>>>> at your house? you say "yes" even though
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct the answer is "no".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You really like to make you Herrings Red,
>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>> that H applied to wM w is based on the
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of M applied to w.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When anyone in the universe defines something
>>>>>>>>>>>>>>>>>>>>>>>>>> besides the actual behavior specified by the
>>>>>>>>>>>>>>>>>>>>>>>>>> input to embedded_H as the only correct halt
>>>>>>>>>>>>>>>>>>>>>>>>>> status criterion measure that might as well
>>>>>>>>>>>>>>>>>>>>>>>>>> say that cats are not animals.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Just shows your problem in comprehension,
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't it. You just refuse to accept the
>>>>>>>>>>>>>>>>>>>>>>>>> definition because it doesn't match your idea
>>>>>>>>>>>>>>>>>>>>>>>>> of what you need.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the
>>>>>>>>>>>>>>>>>>>>>>>>> input' IS precisly defined, and it IS the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior that the input specifes, The input to
>>>>>>>>>>>>>>>>>>>>>>>>> the decider is the description of a
>>>>>>>>>>>>>>>>>>>>>>>>> computation, and the actual behavior sepecified
>>>>>>>>>>>>>>>>>>>>>>>>> by the input is by defintion the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>> that computation that the input describes.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one that wants to change it to not
>>>>>>>>>>>>>>>>>>>>>>>>> be the behavior specified by the input, but the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the program that is processing the
>>>>>>>>>>>>>>>>>>>>>>>>> input. YOUR definition of the behavior has the
>>>>>>>>>>>>>>>>>>>>>>>>> problem that the behavior is no longer just
>>>>>>>>>>>>>>>>>>>>>>>>> specified by 'the input' but is also a function
>>>>>>>>>>>>>>>>>>>>>>>>> of what program you give that input to.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Your logic is just not sound, and sometimes I
>>>>>>>>>>>>>>>>>>>>>>>>> wonder how sound your mind is.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This statement of your just shows how you have
>>>>>>>>>>>>>>>>>>>>>>>>> lost touch with the reality of the situation.
>>>>>>>>>>>>>>>>>>>>>>>>> You seem to think the Univese must be wrong
>>>>>>>>>>>>>>>>>>>>>>>>> because it doesn't match your expectations.
>>>>>>>>>>>>>>>>>>>>>>>>> THAT is a sign of mental illness.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do
>>>>>>>>>>>>>>>>>>>>>>> if H^ <H^> Will Halt.
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do
>>>>>>>>>>>>>>>>>>>>>>> if H^ <H^> will never Halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> you keep forgetting the conditions, which are
>>>>>>>>>>>>>>>>>>>>>>> important.
>>>>>>>>>>>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence
>>>>>>>>>>>>>>>>>>>>>> of configurations than embedded_H applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ therefore embedded_H can transition to Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>> causing Ĥ to transition to Ĥ.qn without
>>>>>>>>>>>>>>>>>>>>>> contradiction.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Bing a pathological liar seems to have made you
>>>>>>>>>>>>>>>>>>>>> lose your sense of what is true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> While H^ applied to <H^> IS a different computation
>>>>>>>>>>>>>>>>>>>>> then H applied to <H^> <H^> the former uses the
>>>>>>>>>>>>>>>>>>>>> latter to determine its behavior.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The issue isn't a 'contradiction' between the
>>>>>>>>>>>>>>>>>>>>> behavior of the two machines but the contradiction
>>>>>>>>>>>>>>>>>>>>> between the behavior of these two machines and the
>>>>>>>>>>>>>>>>>>>>> concept that H is correct.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Like the guard that is only accountable for
>>>>>>>>>>>>>>>>>>>>>> guarding the front door simulating halt decider
>>>>>>>>>>>>>>>>>>>>>> embedded_H is only accountable for reporting
>>>>>>>>>>>>>>>>>>>>>> whether or not its simulated input can possibly
>>>>>>>>>>>>>>>>>>>>>> reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Again, you pathological lying has blinded you to
>>>>>>>>>>>>>>>>>>>>> the actual fact.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H/embedded_H IS responsible for its answer match
>>>>>>>>>>>>>>>>>>>>> the the ACTUAL 'Behavior of its input', which is
>>>>>>>>>>>>>>>>>>>>> DEFINED as the behavior of the ACTUAL MACHINE the
>>>>>>>>>>>>>>>>>>>>> input represents.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You have this misconception welded into your brain.
>>>>>>>>>>>>>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You answer yes because Bill's lawyer came over and
>>>>>>>>>>>>>>>>>>>> Bill's lawyer represents Bill.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Say what you will, but the DEFINTION of what a Halt
>>>>>>>>>>>>>>>>>>> Decider is supposed to answer on is the actual
>>>>>>>>>>>>>>>>>>> behavior of the machine that the input represents.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the court is trying to establish an alibi for Bill
>>>>>>>>>>>>>>>>>> and you answer this on the basis that Bill's lawyer
>>>>>>>>>>>>>>>>>> instead of Bill you would go to prison for perjury.
>>>>>>>>>>>>>>>>>> This proves that you are not allowed to use the term
>>>>>>>>>>>>>>>>>> "represents" to refer to something else somewhere else.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, do you think you should go to jail for the perjury
>>>>>>>>>>>>>>>>> of Ha reporting on the behavior of Hn^ instead if Ha^?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is your wrong answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When a finite string Turing machine description
>>>>>>>>>>>>>>>>>> represents a Turing Machine then the UTM simulation of
>>>>>>>>>>>>>>>>>> the finite string will always have computationally
>>>>>>>>>>>>>>>>>> equivalent behavior to the direct execution of the
>>>>>>>>>>>>>>>>>> Turing machine.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, A REAL UTM, which never aborts its simulation,
>>>>>>>>>>>>>>>>> but is non-halting if its input represents a
>>>>>>>>>>>>>>>>> non-halting computation, as is part of the defintion of
>>>>>>>>>>>>>>>>> a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When embedded_H correctly determines that the pure
>>>>>>>>>>>>>>>> simulation of its input by a real UTM would never reach
>>>>>>>>>>>>>>>> the final state of this input and it makes this
>>>>>>>>>>>>>>>> determination in a finite number of steps, then it is
>>>>>>>>>>>>>>>> necessarily correct for embedded_H  to transition to its
>>>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that the 'correct determination' was based on the
>>>>>>>>>>>>>>> assumption that H/embedded_H IS just a UTM,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is factually incorrect. embedded_H determines what
>>>>>>>>>>>>>> the behavior of its input would be if its was simulated by
>>>>>>>>>>>>>> UTM instead of a simulating halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but in doing so it does NOT change the copy of H
>>>>>>>>>>>>> inside of H^ into a UTM. The copy of H (you call it
>>>>>>>>>>>>> embedded_H) must behave exactly like H does. H needs to
>>>>>>>>>>>>> decide on what a UTM would do with its same input where the
>>>>>>>>>>>>> copy of H in that input does the same thing as H does.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Unless you can show a Turing Machine diferent copies of
>>>>>>>>>>>>> which behave differently when given the same input, you
>>>>>>>>>>>>> haven't shown what you need to. (And if you could show
>>>>>>>>>>>>> that, that by itself would make you famous).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I have a really great answer for this yet deleted it because
>>>>>>>>>>>> of your subterfuge on the next line.
>>>>>>>>>>>
>>>>>>>>>>> What 'subterfuge', that was just a simple statement of facts
>>>>>>>>>>> based on definitons.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I repeatedly tell you that infinite behavior can be detected
>>>>>>>>>> in finite steps and you reject this out-of-hand.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I've proven otherwise for this case, but that isn't the issue
>>>>>>>>> here. Your whole 'proof' that H^ is non-halting is based on the
>>>>>>>>> assumption that embedded_H is a non-aborting UTM,
>>>>>>>> No not at all I didn't say anything like this, and I have
>>>>>>>> corrected you on this mistake many dozens of times.
>>>>>>>>
>>>>>>>
>>>>>>> You might not SAY that you make that assumption, but your proof
>>>>>>> only holds under that condition.
>>>>>>>
>>>>>>
>>>>>> You simply have never been hardly paying any attention at all.
>>>>>>
>>>>>
>>>>> That is just a dishonest dodge because I pointed out something you
>>>>> don't know how to counter.
>>>>>
>>>>
>>>> Your replies always indicate that you didn't bother to hardly pay
>>>> any attention to what I said. Anyone carefully reading them would
>>>> see this.
>>>>
>>>>
>>>
>>> No, YOUR replies are so full of logical falicies I could illustrate a
>>> comprensive book of them with quotes from your writing.
>>>
>>> For instance, you are currently avoiding dealing with the
>>> difficulties I placed on you by making personal attacks.
>>
>> See that you don't even comprehend how the ad hominem fallacy works.
>>
>>
>
> Maybe you don't understand the fallicy. Rather than defending your
> position by showing some logical reason you are right, you 'defend' your
> position by saying I am in some way not 'qualified' to rebut you.
I explain how I am necessarily correct on the basis of the meaning of my
words and you disagree on the basis of your failure to correctly
understand the meaning of these words.

THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE
MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number
of steps that the pure UTM simulation of its input would never reach the
final state of this input then it can correctly reject this input as
non-halting.

In epistemology (theory of knowledge), a self-evident proposition is a
proposition that is known to be true by understanding its meaning
without proof... https://en.wikipedia.org/wiki/Self-evidence

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer