On 4/10/22 10:53 PM, olcott wrote:
> On 4/10/2022 9:47 PM, Dennis Bush wrote:
>> On Sunday, April 10, 2022 at 10:44:25 PM UTC-4, olcott wrote:
>>> On 4/10/2022 9:41 PM, Dennis Bush wrote:
>>>> On Sunday, April 10, 2022 at 10:38:33 PM UTC-4, olcott wrote:
>>>>> On 4/10/2022 9:32 PM, Dennis Bush wrote:
>>>>>> On Sunday, April 10, 2022 at 10:27:20 PM UTC-4, 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.
>>>>>>
>>>>>> Multiple candidate halt deciders H can exist, with each one
>>>>>> potentially getting cases right that another might get wrong. Ha3
>>>>>> is one of these. The multiple halt deciders you refer to as "H"
>>>>>> (and which Ha3 is actually a part of) are others. So if one
>>>>>> simulating halt decider X reports a given input as non-halting,
>>>>>> and if another simulating halt decider Y is given the same input
>>>>>> and reports halting, would you agree that Y shows that X was
>>>>>> incorrect because it didn't simulate for long enough?
>>>>>>
>>>>> That is too far off topic. I have been talking circles with Ben for 17
>>>>> years. We now must talk in hierarchies, cyclic paths are trimmed
>>>>> off of
>>>>> the decision tree.
>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qn
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>> Then these steps would keep repeating:
>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>
>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>>>>> non-halting.
>>>>
>>>> Now you're the one getting off topic. We were talking about how to
>>>> determine whether a given simulating halt decider is giving the
>>>> correct answer, which is actually relevant to what you just posted.
>>>>
>>>> If one simulating halt decider X reports a given input as
>>>> non-halting, and if another simulating halt decider Y is given the
>>>> same input and reports halting, would you agree that Y shows that X
>>>> was incorrect because it didn't simulate for long enough?
>>>>
>>> There is a single ULTIMATE MEASURE of the correctness of a halt decider
>>> and that is whether its correctly simulated input would halt.
>>
>> That being the case, if X simulates a given input and reports
>> non-halting, and Y simulates the same input and (never leaving UTM
>> mode) reports halting, wouldn't that mean the correctly simulated
>> input would halt?
>
> It is self-evident that the actual behavior of the actual simulated
> input is the ULTIMATE MEASURE of the correctness of any halt decider.
>
> In epistemology (theory of knowledge), a self-evident proposition is a
> proposition that is known to be true by understanding its meaning
> without proof... https://en.wikipedia.org/wiki/Self-evidence
>
>

But we aren't using epistemology. In Formal Logic, 'Self-Evident' is NOT
proof of correctly, only a FORMAL PROOF is, based on the formal
defintions and Axioms of the logic.

'Self-Evident' is the source of errors like that Achilles can't pass the
Tortoise.

Note also, you aren't using the right meanings of words, so you aren't
even correctly applying the principle, PROVING that you are incompetent
to work in this field, and just a blantent liar to even be claiming that
things are self-evident which are provably false.

FAIL.