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.
>
> This proves that the behavior of the pure simulation of the input ⟨Ĥ⟩
> ⟨Ĥ⟩ to embedded_H is the correct measure of the behavior that this
> finite string pair specifies.
>

Yes, if H IS a real UTM, then H^ applied to <H^> is non-halting, but
your problem is that then H never returns an answer, so it isn't a
coorect Halting Decider.

H/embedded_H can't be both a real UTM, and also abort its simulation to
return the answer you want.

If H isn't actually a UTM, then analysing the computation as if it was
one is just unsound.

FAIL.