On 4/10/22 10:27 PM, olcott wrote:
> On 4/10/2022 9:17 PM, Dennis Bush wrote:
>> On Sunday, April 10, 2022 at 10:09:41 PM UTC-4, olcott wrote:
>>> On 4/10/2022 9:06 PM, Dennis Bush wrote:
>>>> On Sunday, April 10, 2022 at 10:02:56 PM UTC-4, olcott wrote:
>>>>> On 4/10/2022 8:59 PM, Dennis Bush wrote:
>>>>>> On Sunday, April 10, 2022 at 9:55:22 PM UTC-4, olcott wrote:
>>>>>>> On 4/10/2022 8:53 PM, Dennis Bush wrote:
>>>>>>>> On Sunday, April 10, 2022 at 9:43:47 PM UTC-4, olcott wrote:
>>>>>>>>> On 4/10/2022 8:38 PM, Dennis Bush wrote:
>>>>>>>>>> On Sunday, April 10, 2022 at 9:36:11 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 4/10/2022 8:30 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:26:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 4/10/2022 8:17 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:13:23 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 4/10/2022 8:10 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:07:18 PM UTC-4, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 4/10/2022 8:03 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:00:25 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 8:40:34 PM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:28 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 7:58:55 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 6:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 7:20:44 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 6:14 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 17:08, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 5:59 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 16:40, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 5:35 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 15:56, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:49 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 15:00, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 3:07 PM, André G. Isaak
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I'm trying to get you to write using
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and coherent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notation. That's one of the things
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you'll need to be able to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do if you ever hope to publish. That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> involves remembering to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always include conditions and using
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same terms in your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'equations' as in your text.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Not sure how that makes me a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'deceitful bastard'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT you pretended to not know what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mean by embedded_H so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you could artificially contrive a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fake basis for rebuttal
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when no actual basis for rebuttal
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exists makes you a deceitful
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bastard.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IT IS THE CASE THAT the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H never reaches its own final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ0.qy⟩ or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0.qn⟩ under any condition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever therefore ⟨Ĥ0⟩ ⟨Ĥ1⟩ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved to specify a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ2⟩ ⊢* H.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is now the third reply you've made
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the same post.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That post didn't make any arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whatsoever about your claims.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It simply pointed out that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> misusing your notation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> urged you to correct it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE NOTATION IS A STIPULATIVE DEFINITION
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THUS DISAGREEMENT IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INCORRECT.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the notation is junk, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition is also junk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's like "stipulating" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +×yz÷² = ±z+³
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's meaningless because the notation is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaningless, much like
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your notation above.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is meaningless:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy // what's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the condition?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qn // what's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the condition?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With no conditions specified, the above is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is still nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>> own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would never
>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And again you're still being inconsistent. You
>>>>>>>>>>>>>>>>>>>>>>>>>> can either use H or use
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H, but you can't mix the two.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Sure I can. I just did.
>>>>>>>>>>>>>>>>>>>>>>>>>>> This means that H pretends that it is only a
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM to see what its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would do in this case. If it
>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>> final state then H correctly rejects this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A Turing Machine cannot "pretend" to be some
>>>>>>>>>>>>>>>>>>>>>>>>>> different Turing Machine.
>>>>>>>>>>>>>>>>>>>>>>>>> It can perform a pure simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>> until this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>> matches a repeating behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>> proves this input never
>>>>>>>>>>>>>>>>>>>>>>>>> reaches its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If that's the case, why does an actual UTM
>>>>>>>>>>>>>>>>>>>>>>>> applied to the *same* input halt?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Hint: Because the result of an actual UTM
>>>>>>>>>>>>>>>>>>>>>>>> applied to the input defines the correct answer,
>>>>>>>>>>>>>>>>>>>>>>>> so H answers wrong.
>>>>>>>>>>>>>>>>>>>>>>> Intuitively that would seem to be true, this
>>>>>>>>>>>>>>>>>>>>>>> intuition is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The ultimate definition of correct is the
>>>>>>>>>>>>>>>>>>>>>>> computation of the mapping of
>>>>>>>>>>>>>>>>>>>>>>> the inputs to an accept or reject state on the
>>>>>>>>>>>>>>>>>>>>>>> basis of the behavior
>>>>>>>>>>>>>>>>>>>>>>> that these inputs specify.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That simulated inputs to embedded_H would never
>>>>>>>>>>>>>>>>>>>>>>> reach their own final
>>>>>>>>>>>>>>>>>>>>>>> state under any condition what-so-ever
>>>>>>>>>>>>>>>>>>>>>>> IS THE ULTIMATE MEASURE OF THEIR HALTING BEHAVIOR
>>>>>>>>>>>>>>>>>>>>>>> and conclusively proves they specify a
>>>>>>>>>>>>>>>>>>>>>>> non-halting sequence of
>>>>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Since embedded_H is the same as H (as you have yet
>>>>>>>>>>>>>>>>>>>>>> to provide any evidence to the contrary), then the
>>>>>>>>>>>>>>>>>>>>>> above can be applied to any simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The topic is the single point that the simulated
>>>>>>>>>>>>>>>>>>>>> input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
>>>>>>>>>>>>>>>>>>>>> embedded_h cannot possibly reach its own final
>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And that same logic gives us this:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That simulated inputs <N><5> to Ha3 would never
>>>>>>>>>>>>>>>>>>>> reach their own final
>>>>>>>>>>>>>>>>>>>> state under any condition what-so-ever
>>>>>>>>>>>>>>>>>>>> IS THE ULTIMATE MEASURE OF THEIR HALTING BEHAVIOR
>>>>>>>>>>>>>>>>>>>> and conclusively proves they specify a non-halting
>>>>>>>>>>>>>>>>>>>> sequence of
>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> THE SIMULATED INPUT CANNOT POSSIBLY REACH ITS OWN
>>>>>>>>>>>>>>>>>>>> FINAL STATE
>>>>>>>>>>>>>>>>>>>> THIS SINGLE FACT BY ITSELF PROVES THAT THE INPUT IS
>>>>>>>>>>>>>>>>>>>> CORRECTLY REJECTED
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Try to find an error in the above.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That simulated inputs <N><5> to Ha3
>>>>>>>>>>>>>>>>>>> are pure nonsense gibberish.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So you agree that Ha3 is correct to reject <N><5>?
>>>>>>>>>>>>>>>>> It has no associated meaning
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Sure it does. Ha3 is a simulating halt decider whose
>>>>>>>>>>>>>>>> halt status criteria is to abort after 3 steps, and N
>>>>>>>>>>>>>>>> takes <n> as input and runs for exactly n steps before
>>>>>>>>>>>>>>>> halting in state N.qy. And Ha3 rejects <N><5>.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That simulated inputs <N><5> to Ha3 would never reach
>>>>>>>>>>>>>>>> their own final
>>>>>>>>>>>>>>> You are starting with a broken halt decider, my rules
>>>>>>>>>>>>>>> only apply to
>>>>>>>>>>>>>>> correct halt deciders.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is like you are saying that no one can possibly drive
>>>>>>>>>>>>>>> their car and
>>>>>>>>>>>>>>> to prove this you drive your car into a tree.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So what criteria would you apply to Ha3 to determine that
>>>>>>>>>>>>>> it's broken?
>>>>>>>>>>>>> I would simply say that ridiculously stupid ideas such as
>>>>>>>>>>>>> Ha3 should
>>>>>>>>>>>>> never be presented by someone with your top 0.04%
>>>>>>>>>>>>> reputation they
>>>>>>>>>>>>> denigrate you. You must know how stupid this idea was
>>>>>>>>>>>>> before you first
>>>>>>>>>>>>> mentioned it.
>>>>>>>>>>>>
>>>>>>>>>>>> If it's so obvious to you that Ha3 is broken, then you
>>>>>>>>>>>> should be able to explain exactly how to determine that.
>>>>>>>>>>> Obviously a very lame attempt at a head game by a guy with
>>>>>>>>>>> your reputation.
>>>>>>>>>>
>>>>>>>>>> Explain how you would determine Ha3 is broken. If you don't,
>>>>>>>>>> I'll be forced to conclude that you agree that it's correct.
>>>>>>>>> I will quit talking to you until you stop the head games.
>>>>>>>>
>>>>>>>> That you have difficultly following my logic (actually, your own
>>>>>>>> logic applied to a different halt decider) doesn't mean I'm
>>>>>>>> playing head games.
>>>>>>>>
>>>>>>>> Explain exactly how you would determine that Ha3 is broken, or
>>>>>>>> admit that it is not.
>>>>>>> You know that the question is mere denigration:
>>>>>>> https://en.wikipedia.org/wiki/UFTP
>>>>>>
>>>>>> This is how you know you're stuck, when you go completely off topic.
>>>>>>
>>>>>> Explain exactly how you would determine that Ha3 is broken, or
>>>>>> admit that it is not.
>>>>> I will ask you a similar question in the same vein:
>>>>>
>>>>> Exactly how do you know that driving a car into a tree is not a very
>>>>> good way to see how a car drives, please provide every single detail.
>>>>
>>>> Dishonest dodge.
>>>>
>>>> If Ha3 is broken, explain exactly how you would determine that. Tell
>>>> us how you would determine that the result that a simulating halt
>>>> decider gives is correct.
>>> I thought of a good way to answer this.
>>> It does not meet the specs of a simulating halt decider.
>>>
>
> A simulating halt decider must continue to simulate its input until it
> has proof that this simulation would never end.
>
>>
>> Since a given halt decider X has a fixed algorithm, that would mean
>> the input would need to be passed to a different halt decider Y.  So
>> if Y showed that the input halts, would you agree that it shows that X
>> was incorrect to report non-halting?
>
> The given halt decider has a fixed algorithm that can be applied to any
> input on its tape. The whole idea of Y seems pretty crazy.
>

Except that your H has NEVER had a fixed algorithm, but has ALWAYS be
based on squishy terms.

Things like claiming there is a pattern to match to, but never being
able to actually GIVE that pattern (an proofs being given that such a
pattern can not exist).

That or it is based on USOUND logic like assuing a behavior of H, that H
doesn't actually have, (like not aborting) and then claiming that it got
the right answer as it 'magically' changed from that other behavior
(which it doesn't have) to another.

FAIL.