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.

--
Copyright 2021 Pete Olcott

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