On 3/26/2022 8:28 PM, Richard Damon wrote:
> On 3/26/22 9:05 PM, olcott wrote:
>> On 3/26/2022 7:39 PM, Richard Damon wrote:
>>> On 3/26/22 7:58 PM, olcott wrote:
>>>> On 3/26/2022 6:54 PM, Richard Damon wrote:
>>>>> On 3/26/22 7:40 PM, olcott wrote:
>>>>>> On 3/26/2022 6:32 PM, Richard Damon wrote:
>>>>>>> On 3/26/22 7:09 PM, olcott wrote:
>>>>>>>> On 3/26/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>> On 3/26/22 6:36 PM, olcott wrote:
>>>>>>>>>> On 3/26/2022 5:27 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/26/22 6:14 PM, olcott wrote:
>>>>>>>>>>>> On 3/26/2022 5:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/26/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/26/2022 4:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/26/22 5:21 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/26/2022 4:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/26/22 5:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/26/2022 3:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/26/22 4:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/26/2022 3:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/26/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 2:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 12:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 11:35 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 12:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 10:50 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 11:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 9:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 10:13 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:11 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2022 10:48 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A SHD computes the mapping
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its input to its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state based on whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input could reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state in a finite number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> syntax for the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine Ĥ, it is now a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single machine with a single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> start
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.  A copy of Linz H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Or, more simply, use Linz's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition: if Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it turns out to be the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a halt decider is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report on its own behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because itself is neither an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input nor a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No.  Happy to answer questions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about why this is wrong, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> since you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have not grasped what a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider is after 17 years, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it's worth my while just writing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it out yet again.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are agreed that a decider maps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input finite string input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Now you are contradicting yourself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by saying that a decider maps a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input non-finite string.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, what it is mapping is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input <H^> <H^> which most
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitely IS a finite string input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is to map it to Qy (accept) or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Qn (reject) based on if the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^   applied to <H^> Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact tha H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't exactly an input if fine,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am looking for white dogs in my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> kitchen by looking for black cats in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> my living room.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, EXACTLY. YOU ARE. This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because you aren't using the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of HALTING. (Halting is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the white dog, your POOP is the black
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cats).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting is DEFINED based on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavoir of the TURING MACHINE that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input represents, NOT a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input by the decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only correct halt status criteria
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. THE DEFINITION of the right
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is what the ACTUAL TURING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE the input represents does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input it what counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOPE. READ THE DEFINITION!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the behavior of the ACTUAL TURING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE THE INPUT REPRESENT.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This only means that it is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a finite string because finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strings have no behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right Finite strings have no behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior the decider needs to decide on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the Turing Machine the input is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the UTM simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is the behavior that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies. That the input simulated by a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> except that if H <H^> <H^> -> Qn, then H^
>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> and UTM <H^> <H^> will also gp tp H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>> and halt, so your claim is a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Eitehr you LIE that your deicder said its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input was non-halting, or you LIE that
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not reach a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't use two different version of
>>>>>>>>>>>>>>>>>>>>>>>>>>> H/embedded_H here.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior referred to must be the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as the behavior of the simulated Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description otherwise you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> denying the computational equivalence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of a Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the UTM simulation of the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description of this same machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, the behavior of the ACTUAL Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine, which can also be obtained by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation with a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT 'by embedded_H' but by a UTM. Wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> By the UTM aspect of embedded_H because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation must occur at the same point (in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the middle) of Ĥ where embedded_H is located.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope!!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the INDEPENDENT running of UTM <H^> <H^>.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The invocation of Ĥ ⟨Ĥ⟩ is the first
>>>>>>>>>>>>>>>>>>>>>>>>>> invocation in what would otherwise be infinite
>>>>>>>>>>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Its normal behavior depends on a subsequent
>>>>>>>>>>>>>>>>>>>>>>>>>> invocation being aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If a subsequent invocation is never aborted
>>>>>>>>>>>>>>>>>>>>>>>>>> then the recursion remains infinite.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In any case the simulated input never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this simulated input. The
>>>>>>>>>>>>>>>>>>>>>>>>>> final state of the simulated input is ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, ALL Copies of the same machine given the
>>>>>>>>>>>>>>>>>>>>>>>>> same input behave the same.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is never any case where the simulated
>>>>>>>>>>>>>>>>>>>>>>>> input reaches its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If you want to refute that, provide and ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>>> coded example.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^> -> H^.Qn and Halts and UTM
>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to <H^>.Qn and Halts if
>>>>>>>>>>>>>>>>>>>>>>>>> H/embedded_H -> Qn, and if H doesn't, it fails
>>>>>>>>>>>>>>>>>>>>>>>>> to be a decider, so is wrong either way.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ and embedded_H both reach their final
>>>>>>>>>>>>>>>>>>>>>>>> state of Ĥ.qn and halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
>>>>>>>>>>>>>>>>>>>>>>>> reaches its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope. The PROPERLY simulated <H^> <H^> will also
>>>>>>>>>>>>>>>>>>>>>>> go to H^.Qn and Halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I say I have no white dogs in my living room and
>>>>>>>>>>>>>>>>>>>>>> disagree on the basis that I have a black cat in
>>>>>>>>>>>>>>>>>>>>>> my kitchen.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
>>>>>>>>>>>>>>>>>>>>>> reaches its own final state of ⟨Ĥ.qn⟩ even though
>>>>>>>>>>>>>>>>>>>>>> the directly executed Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>>>>>>>>>>>>>> transition to its final state of Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the
>>>>>>>>>>>>>>>>>>>>>> first invocation of infinite recursion that only
>>>>>>>>>>>>>>>>>>>>>> terminates normally because of its one-way
>>>>>>>>>>>>>>>>>>>>>> dependency relationship on embedded_H aborting the
>>>>>>>>>>>>>>>>>>>>>> second invocation of this otherwise infinite
>>>>>>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And since it DOES Halt, the computation HA\LT.
>>>>>>>>>>>>>>>>>>>>> DEFINITION.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> As you were the first to point out the simulated
>>>>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H does not halt. To use
>>>>>>>>>>>>>>>>>>>> your own terms its execution has been suspended.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> YOU KNOW THIS IS TRUE YOU ARE JUST A LIAR
>>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
>>>>>>>>>>>>>>>>>>>> reaches its own final
>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ.qn⟩ even though the directly executed Ĥ
>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> does transition to its final state of Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The PARTIAL simulation of the input by embedded_H
>>>>>>>>>>>>>>>>>>> never reaches its final state, yes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since you already agreed that the complete simulation
>>>>>>>>>>>>>>>>>> of its input never stops running you already know that
>>>>>>>>>>>>>>>>>> the simulation of its input never reaches its final
>>>>>>>>>>>>>>>>>> state ⟨Ĥ.qn⟩ no matter what.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then that means your embedded_H NEVER aborts its
>>>>>>>>>>>>>>>>> simulation, and thus NEVER returns an annswer and thus
>>>>>>>>>>>>>>>>> FAILS to be a decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It also means that because the input never halts under
>>>>>>>>>>>>>>>> any circumstances that when embedded_H rejects this
>>>>>>>>>>>>>>>> input it is necessarily correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, that isn't what I agreed to.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sure it was.
>>>>>>>>>>>>>> It doesn't reach its final state if it is not aborted (it
>>>>>>>>>>>>>> keeps running) and it doesn't reach its final state if was
>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Bad use of pronouns.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by the UTM inside of embedded_H never
>>>>>>>>>>>> reaches its final state: ⟨Ĥ.qn⟩ no matter what.
>>>>>>>>>>>
>>>>>>>>>>> There IS NO UTM that is still a UTM inside embedded_H, or
>>>>>>>>>>> embedded_H doesn't ever answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You know that the simulated input to embedded_H never reaches
>>>>>>>>>> its final state of ⟨Ĥ.qn⟩ no matter what. Why don't you just
>>>>>>>>>> admit this so that I can escalate this to computer science
>>>>>>>>>> review?
>>>>>>>>>
>>>>>>>>> Because you are saying it wrong, because you are confusing two
>>>>>>>>> different 'simulations'
>>>>>>>>>
>>>>>>>>> The CORRECTLY Simulated input, done by the independent UTM,
>>>>>>>> Has never been what I am talking about and you know it.
>>>>>>>>
>>>>>>>
>>>>>>> So you admit that you are only talking about the INCORRECTLY
>>>>>>> Simulated Output?
>>>>>>
>>>>>> No nitwit I admit no such thing.
>>>>>
>>>>> Then why did you say it?
>>>>>
>>>>> I talked about the 'CORRECT Simulation' and you say that you aren't
>>>>> talking about that.
>>>>>
>>>>> What is the defintion of a simulation that isn't the correct
>>>>> simulation?
>>>>>
>>>>> You don't seem to understand the meaning of English words.
>>>>>
>>>>>>
>>>>>> The input simulated by the UTM contained within embedded_H cannot
>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ if simulated in an
>>>>>> infinite or finite number of steps or if the simulation is aborted
>>>>>> at any point along the way.
>>>>>>
>>>>>>
>>>>>
>>>>> As I have said, there IS NO UTM contained within embedded_H that is
>>>>> still a UTM if embedded_H EVER aborts its simulation.PERIOD.
>>>>
>>>> A music app can contain a complete C compiler that remains a
>>>> complete C compiler even if it is never uses.
>>>>
>>>>
>>>
>>> RED HERRING. Category error. (Since you claim embedded_H USES the
>>> UTM, your case in non-applicable).
>>>
>> If embedded_H uses its UTM to simulate one state transition at a time
>> of its input then each of these state transitions are simulated
>> correctly.
>>
>
> The step maybe, the MACHINE, NO.
>
> Definition of Correct Simulation, behaves IDENTICAL to the original
> machine.
>
> Means can not 'abort' the simulation.
>
> FAIL.

If a simulating halt decider cannot abort an otherwise infinite
simulation then you are artificially requiring it to be wrong where it
would otherwise be correct.

--
Copyright 2022 Pete Olcott

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