On 1/23/2022 9:57 PM, Richard Damon wrote:
>
> On 1/23/22 10:40 PM, olcott wrote:
>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>> On 1/23/22 10:10 PM, olcott wrote:
>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true for infinite loops, infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion, infinitely nested simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> all other non halting inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulated input to any
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this simulated input in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> any finite number of steps it is always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for the simulating halt decider to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and transition to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you PROVE that statement, or is this just
>>>>>>>>>>>>>>>>>>>>>>>>>>> one of your false 'self evident truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that x86 language can tell
>>>>>>>>>>>>>>>>>>>>>>>>>> that its easy to match the infinite loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe            jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4] 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4] 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4] ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4] ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do one case does not prove
>>>>>>>>>>>>>>>>>>>>>>>>> that the same method works on all, particularly
>>>>>>>>>>>>>>>>>>>>>>>>> harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That is just you serving Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does NOT show up in the
>>>>>>>>>>>>>>>>>>>>>>>>> simulation by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE lies by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof include the posibility that
>>>>>>>>>>>>>>>>>>>>>>>>>>> the input includes a copy of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case that a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior pure simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ -> H^.Qn and Halts and for
>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must be true because we know
>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure UTM simulation of an Turing
>>>>>>>>>>>>>>>>>>>>>>>>>> Machine description is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to that of the direct
>>>>>>>>>>>>>>>>>>>>>>>>>> execution of the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't prove what you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out of your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that IF the simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider does abort its input based on some
>>>>>>>>>>>>>>>>>>>>>>>>>>> condition, then it is no longer a source of
>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for the halting status of that input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is not answering the question: Does the
>>>>>>>>>>>>>>>>>>>>>>>>>> input stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, which H are you using?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, then H^ is non-halting, but
>>>>>>>>>>>>>>>>>>>>>>>>> H will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go to H.Qn, then the pure
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input WILL halt at H^.Qn, so
>>>>>>>>>>>>>>>>>>>>>>>>> H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure simulation of the input ever
>>>>>>>>>>>>>>>>>>>>>>>>>> stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT ENOUGH TO GET THIS. IT
>>>>>>>>>>>>>>>>>>>>>>>> CAN BE VERIFIED AS COMPLETELY TRUE ENTIRELY ON
>>>>>>>>>>>>>>>>>>>>>>>> THE BASIS OF THE MEANING OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if embedded_H recognizes an
>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating pattern in the simulation
>>>>>>>>>>>>>>>>>>>>>>>> of its input such that this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly reach its final state then
>>>>>>>>>>>>>>>>>>>>>>>> this is complete prove that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY recognize an infinitely
>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>> simulation that can not possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>> state (when simulated by a UTM, not just H) then,
>>>>>>>>>>>>>>>>>>>>>>> YES, H can go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The problem is that due to 'pathological
>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^, ANY pattern that H sees in
>>>>>>>>>>>>>>>>>>>>>>> its simulation of <H^> <H^> that it transitions
>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will BY DEFINITION, become a halting
>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated INPUT that cannot
>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state reaches its final
>>>>>>>>>>>>>>>>>>>>>> state anyway. YOU ARE DUMBER THAN A BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That's not what I said, I said there is no pattern
>>>>>>>>>>>>>>>>>>>>> that H use to detect that it won't halt, as any
>>>>>>>>>>>>>>>>>>>>> pattern that H uses to decide to go to H.Qn will be
>>>>>>>>>>>>>>>>>>>>> WRONG for H^ as if H goes to H.Qn, then H^ also
>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When the correctly simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state it is
>>>>>>>>>>>>>>>>>>>> necessarily correct for embedded_H to report that
>>>>>>>>>>>>>>>>>>>> its correctly simulated INPUT cannot possibly reach
>>>>>>>>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right,  but you have only proved that H^ is
>>>>>>>>>>>>>>>>>>> non-halting for the case where H doesn't abort its
>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because you are dumber than a box of rocks (or perhaps
>>>>>>>>>>>>>>>>>> you are a bot?)
>>>>>>>>>>>>>>>>>> You did not notice that I never mentioned the word:
>>>>>>>>>>>>>>>>>> "halting".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> For a human being you are much dumber than a box of
>>>>>>>>>>>>>>>>>> rocks.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> For a bot you did quite well (you nearly passed the
>>>>>>>>>>>>>>>>>> Turing test) it took me this long to realize that you
>>>>>>>>>>>>>>>>>> are not a human being.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But reaching final state is the same as Halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You have only prove that the pure simulation of the
>>>>>>>>>>>>>>>>> input to H never reaches a final state for case when H
>>>>>>>>>>>>>>>>> doesn't abort its simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You deliberate weasel words do not apply to what I said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated INPUT to
>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final state
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H
>>>>>>>>>>>>>>>> to report that its correctly simulated INPUT cannot
>>>>>>>>>>>>>>>> possibly reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And the correct simulation of the input to H is
>>>>>>>>>>>>>>> determined by the UTM, not H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (2) is a logical consequence of (1).
>>>>>>>>>>>>>> It is logically incorrect to argue with a deductive
>>>>>>>>>>>>>> logical premise.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But 1 is only true if H doesn't go to H.Qn, so H can't
>>>>>>>>>>>>> correctly go to H.Qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are quite the deceiver making sure to always change the
>>>>>>>>>>>> subject rather than directly address the point at hand.
>>>>>>>>>>>
>>>>>>>>>>> And you seem quite dense. I did NOT change the subject, I
>>>>>>>>>>> pointed out an error in your statement. You seem to be unable
>>>>>>>>>>> to comprehend that.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>
>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> -> H.Qn, as the correctly
>>>>>>>>>>> simulate input
>>>>>>>>>>
>>>>>>>>>> When testing whether or not one assertion logically follows
>>>>>>>>>> from another the premises are always "given" to be true even
>>>>>>>>>> if they are false.
>>>>>>>>>
>>>>>>>>> Don't know what sort of logic you are claiming.
>>>>>>>>>
>>>>>>>>> And arguemnt with a false premise is unsound.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We are not yet looking at soundness we are looking at validity.
>>>>>>>> It is true that (2) logically follows from (1).
>>>>>>>> We can't move on from this one point until we have mutual
>>>>>>>> agreement.
>>>>>>>>
>>>>>>>
>>>>>>> Very strange then, why are you arguing about that which was
>>>>>>> accepted unless you disagree to the conditions that they were
>>>>>>> accepted under?
>>>>>>>
>>>>>>> It has long been accepted that the under the hypothetical
>>>>>>> condition where H can actually determine that the UTM will run
>>>>>>> forever, it is correct (and in fact needed to be correct) for H
>>>>>>> to go to H.Qn and say non-halting.
>>>>>>>
>>>>>>
>>>>>> OKAY so then you agree with this?
>>>>>>
>>>>>> (1) Premise: When the correctly simulated INPUT to embedded_H
>>>>>> cannot possibly reach its final state
>>>>>>
>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>> reach its final state.
>>>>>>
>>>>>
>>>>> Under the definition that 'correctly simulated input' is as
>>>>> determined by a UTM, not H (if it aborts its simulation).
>>>>>
>>>>
>>>> It is only stipulated to be correct other details are currently
>>>> unspecified.
>>>
>>> That isn't a 'stipulation', that is a DEFINITION.
>>>
>>> This is obviously your attempt at being a weasel.
>>>
>>> The DEFINITION of correct simulation is the results of a UTM
>>> simulating the input.
>>>
>>> Any deviaiton in this means you are just eating your POOP.
>>>
>>>>
>>>>> It also does not presume that H CAN determine that this condition
>>>>> exists, so it would be correct, but H might not be able to decide
>>>>> to do so. So it may be correct for it to do so, but it might not
>>>>> actually be able to do it.
>>>>>
>>>>> There is also the case you tend to ignore that you start with an H
>>>>> that is defined to NOT abort, but you try to use (2) to claim that
>>>>> it now can abort, the H is (2) must be the same H that the H^ in
>>>>> (1) was built form
>>>>>
>>>>> All of these restrictions are actually in the actual meaning of the
>>>>> words you are using, from the context of the problem, but I state
>>>>> them because knowing you, you are going to try to break that
>>>>> restrictions.
>>>>>
>>>>
>>>> This seems to be the very first time that you actually paid close
>>>> attention, good jo
>>>>
>>>>> As I asked, how is that different from the statement of the
>>>>> requirements on H?
>>>>>
>>>>
>>>> We define Linz H to base its halt status decision on the behavior of
>>>> its pure simulation of N steps of its input. N is either the number
>>>> of steps that it takes for its simulated input to reach its final
>>>> state or the number of steps required for H to match an infinite
>>>> behavior pattern proving that its simulated input would never reach
>>>> its own final state. In this case H aborts the simulation of this
>>>> input and transitions to H.qn.
>>>>
>>>>
>>>
>>> Note, The correct answer is NOT based on a simulation of N steps, but
>>> a simulation by a UTM which will run until it halts.
>>>
>>> H needs to make ITS decision on the limited N step, so it needs to
>>> prove that its answer matches.
>>>
>>> Remember, when we do this run, H is defined, and thus N is a SPECIFIC
>>> number, not an 'arbitrary' number.
>>>
>>> You also will need to some how prove that a pattern exists in N steps
>>> that correct dectect non-halting.
>>>
>>> This has been previously shown to be impossible, so you need to
>>> actually come up with it or show an actual error in the proof. You
>>> can't just assume it exists.
>>>
>>
>> Great we can move to the next step:
>>
>> (1) Premise: When embedded_H correctly determines its simulated INPUT to
>> embedded_H cannot possibly reach its final state
>>
>> (2) Conclusion: It is necessarily correct for embedded_H to report
>> that its correctly simulated INPUT cannot possibly reach its final state.
>>
>>
> WARNING, you are getting way into hypothecctica Unicoprn Terretory, but
> lets unpack this statement.
>
> IF H can correctly deteremine (that means that there needs to exist a
> finite algroithm to determine this case, and that this result matches
> the behavior demonstrated by the definitional UTM simulataion of this
> input), that the input will NEVER reach it final state,
>
> Then yes, it is correct for H to report that its input can not possible
> reach its final state.
>

Great we have finally begun an honest dialogue.

> Note, that if H does this, then the proof that the input never reached
> its final state must have included that fact that the copy of H inside
> H^ will also do the exact same thing with the exact same input.
>
> Also, to show the premise is True, you need to be able to PROVE or
> actually provide the exact finite algorithm that it used to detemine
> this fact.
>

When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would keep
repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

--
Copyright 2021 Pete Olcott

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