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.

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.

When we know that we have a black cat then we know that we have a cat
and anyone disagreeing either looks very foolish or very dishonest.

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer