On 3/27/2022 7:33 PM, Richard Damon wrote:
> On 3/27/22 8:22 PM, olcott wrote:
>> On 3/27/2022 6:56 PM, Richard Damon wrote:
>>> On 3/27/22 7:37 PM, olcott wrote:
>>>> On 3/27/2022 6:34 PM, Dennis Bush wrote:
>>>>> On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:
>>>>>> On 3/27/2022 6:22 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/27/22 7:16 PM, olcott wrote:
>>>>>>>> On 3/27/2022 6:05 PM, Dennis Bush wrote:
>>>>>>>>> On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 7:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what the correct answer for it is, is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> solely by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Ĥ halts on input ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to say what the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>> It's already
>>>>>>>>>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>>>>>>>>>> specified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Every string either represents a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
>>>>>>>>>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>>>>>>>>> There is no context other than some prior agreed
>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding about
>>>>>>>>>>>>>>>>>>>>>>>>>>> how a TM
>>>>>>>>>>>>>>>>>>>>>>>>>>> and an input should be represented. A halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>>>>>>>>>> must accept
>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly
>>>>>>>>>>>>>>>>>>>>>>>>>>> those strings that represent halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> computations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that you need to reject the very
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>> clear evidence that you know that no TM is a
>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It does not matter why the computation
>>>>>>>>>>>>>>>>>>>>>>>>>>> represented
>>>>>>>>>>>>>>>>>>>>>>>>>>> a particular
>>>>>>>>>>>>>>>>>>>>>>>>>>> string
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. You've been trying to pull this "it only
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts because"
>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>>>>>>>>>>>>> for years.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> could
>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (not
>>>>>>>>>>>>>>>>>>>>>>>>>> anything else in the universe besides it
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs) to
>>>>>>>>>>>>>>>>>>>>>>>>>> its own
>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state based on the actual
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>> these actual inputs (not any behavior of anything
>>>>>>>>>>>>>>>>>>>>>>>>>> else in the
>>>>>>>>>>>>>>>>>>>>>>>>>> universe).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> We also know that the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> specified by
>>>>>>>>>>>>>>>>>>>>>>>>>> these inputs
>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same as the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> this input by a UTM. On this basis we know
>>>>>>>>>>>>>>>>>>>>>>>>>> that any
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> that diverges from this behavior is not the
>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>> basis for
>>>>>>>>>>>>>>>>>>>>>>>>>> the halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated outside of Ĥ then it must have
>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior as Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If it is simulated inside of Ĥ then several
>>>>>>>>>>>>>>>>>>>>>>>>>> steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ have
>>>>>>>>>>>>>>>>>>>>>>>>>> already been executed when this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> begins thus
>>>>>>>>>>>>>>>>>>>>>>>>>> specifying a different sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
>>>>>>>>>>>>>>>>>>>>>>>>>> starts at its beginning.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I assume you have not
>>>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and you know
>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation it
>>>>>>>>>>>>>>>>>>>>>>>>>>> represents is Ĥ applied to the string ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is simulated in the middle of Ĥ this is
>>>>>>>>>>>>>>>>>>>>>>>>>> different than
>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ is simulated at the beginning of Ĥ.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That either is or is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no
>>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
>>>>>>>>>>>>>>>>>>>>>>>>>>> (other
>>>>>>>>>>>>>>>>>>>>>>>>>>> than the
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is obvious that the above sequence is
>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>> If the halt decider aborts the second
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>>>> first recursive call would halt. That the first
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
>>>>>>>>>>>>>>>>>>>>>>>>>> halts does not indicate that it is a halting
>>>>>>>>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> agreed encoding). There is no dispensation from
>>>>>>>>>>>>>>>>>>>>>>>>>>> "special"
>>>>>>>>>>>>>>>>>>>>>>>>>>> kinds of
>>>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't you think that having to have these
>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>> basic matter
>>>>>>>>>>>>>>>>>>>>>>>>>>> explained
>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, year in, year out, indicates that
>>>>>>>>>>>>>>>>>>>>>>>>>>> maybe you
>>>>>>>>>>>>>>>>>>>>>>>>>>> should be
>>>>>>>>>>>>>>>>>>>>>>>>>>> doing
>>>>>>>>>>>>>>>>>>>>>>>>>>> something else?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY
>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> could
>>>>>>>>>>>>>>>>>>>>>>>>>> never reach
>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the universe is
>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, YOU do not grasp that the definitions that
>>>>>>>>>>>>>>>>>>>>>>>>> were
>>>>>>>>>>>>>>>>>>>>>>>>> established
>>>>>>>>>>>>>>>>>>>>>>>>> ARE the definitions you need to use,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Because a halt decider must compute the mapping
>>>>>>>>>>>>>>>>>>>>>>>> from
>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>> finite strings based on the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>> specified
>>>>>>>>>>>>>>>>>>>>>>>> by these
>>>>>>>>>>>>>>>>>>>>>>>> strings which is correctly measured by a correct
>>>>>>>>>>>>>>>>>>>>>>>> simulation of N
>>>>>>>>>>>>>>>>>>>>>>>> steps of these strings you already know that I am
>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope, wrong definition, wrong answer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Do you have a reference for adding the 'of N steps'
>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>> definition?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> N = "simulating it for as many steps as it will take"
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So might be infinite, and thus H fails to answer in
>>>>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You already that this is an infinite pattern:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Note, the ... notation means that you intend the
>>>>>>>>>>>>>>>>>>> pattern to
>>>>>>>>>>>>>>>>>>> keep on
>>>>>>>>>>>>>>>>>>> repeating for ever, so you are SHOWING 3 steps, but
>>>>>>>>>>>>>>>>>>> stateing that more
>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What I said, was that pattern only repeats infinity if
>>>>>>>>>>>>>>>>>>> embedded_H never
>>>>>>>>>>>>>>>>>>> aborts its simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When embedded_H correctly computes the mapping from its
>>>>>>>>>>>>>>>>>> input finite
>>>>>>>>>>>>>>>>>> strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>>>> the behavior that embedded_H (and therefore H) is
>>>>>>>>>>>>>>>>> stipulated
>>>>>>>>>>>>>>>>> to answer about. So anything you say that follows doesn't
>>>>>>>>>>>>>>>>> matter.
>>>>>>>>>>>>>>>> That is a common misconception. Please read my paper.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>> simulation (V4)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've read it, and it's bogus. It says nothing more than what
>>>>>>>>>>>>>>> you've been saying before.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To repeat:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When H3 correctly computes the mapping from its input finite
>>>>>>>>>>>>>>> strings <N> <3> to its own final reject state
>>>>>>>>>>>>>>> on the basis that there is
>>>>>>>>>>>>>>> no finite number N of steps of correct simulation of this
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>> UTM within H3 then H3 has correctly decided that its
>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sure there is, I defined them earlier. But just so there's no
>>>>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So Ha3
>>>>>>>>>>>>> uses
>>>>>>>>>>>>> as its halt status criteria: simulate for 3 steps and abort.
>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>> You might as well define counting to ten: 1,2,3 DONE.
>>>>>>>>>>>
>>>>>>>>>>> So Ha3 is obviously wrong? What criteria do you use to
>>>>>>>>>>> determine that?
>>>>>>>>>> That is an intentionally stupid question.
>>>>>>>>>
>>>>>>>>> I want to hear your answer.  What criteria do you use to show that
>>>>>>>>> Ha3 applied to <N><5> reporting non-halting is incorrect?
>>>>>>>>
>>>>>>>> I take it that you want me to ignore everything you say.
>>>>>>>> This work is intended to be my legacy before I die.
>>>>>>>> If you just want to play head games go fornicate yourself.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> The fact you have trouble with these simple questions shows how
>>>>>>> bad your
>>>>>>> logic is.
>>>>>>>
>>>>>> I told him that his question was just liked counting to ten: 1,2,3
>>>>>> DONE.
>>>>>
>>>>> So in other words H3a is not simulating for enough steps?
>>>>>
>>>>
>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>> As long as the simulated input to embedded_H could never reach its
>>>> final state in any finite number of steps of correct simulation by
>>>> embedded_H then its rejection of this input is necessarily correct.
>>>
>>>
>>> Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED TO DO?
>> That is out-of-scope. You must find an error in my exact words and
>> explain why it is an error, otherwise we get stuck talking in circles
>> that are various shades of the strawman error.
>>
>
> The error in your words is that you don't use the right defintion of
> Halting,

So in other words you disagree with Linz:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

--
Copyright 2022 Pete Olcott

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