On 3/27/2022 7:51 PM, Richard Damon wrote:
> On 3/27/22 8:36 PM, olcott wrote:
>> 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)
>>
>
> Nope, I agree with him, and he says look at the direct execution of the
> machine,

Ah so you believe that Linz does not accept that the direct execution of
Turing machine is computationally equivalent to the UTM simulation of
the Turing machine description of this same machine.

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer