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.

--
Copyright 2021 Pete Olcott

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