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.

H needs to decide what H^ does taking into account that H^ will act in
accordance to what H does.

H must be a specifically defined algorithm at the end, and H^ must be
built using a copy of the exact same algorithm.

One mistake you keep on making is to first assume H works one way, then
prove a behavior of H^ based on that, then change H. The problem is when
you do that, you have also changed H^, so your previously proven
behavior is no longer proven.

You only prove that H^ goes into an infinite loop by assuming the
embedded_H is just a UTM, which means H must also be just a UTM, which
we have shown doesn't answer.

Either you have lied that embedded_H is the exact copy of H, or that you
have proved that it has made the right conclusion.

The fact that you call a statement of fact 'subterfuge' just shows the
untenable position of your 'argument', it can't stand the light of truth.

>
>>>
>>> On the basis that a UTM simulation "never reaches the final state" of
>>> the input then embedded_H knows that its input "never halts" because
>>> "never halts" means "never reaches the final state" of the input.
>>>
>>
>> Right, but that UTM simulation never reaches the final state was only
>> shown when H itself was just a UTM.
>>
>> You don't get to change H mid-stream.
>>
>
>