On 3/28/2022 6:33 AM, Richard Damon wrote:
> On 3/27/22 11:00 PM, olcott wrote:
>> On 3/27/2022 9:29 PM, Richard Damon wrote:
>>> On 3/27/22 10:07 PM, olcott wrote:
>>>> On 3/27/2022 8:52 PM, Richard Damon wrote:
>>>>> On 3/27/22 9:27 PM, olcott wrote:
>>>>>> On 3/27/2022 8:19 PM, Richard Damon wrote:
>>>>>>> On 3/27/22 9:00 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Computationally Equivalent, YES, but only by a REAL UTM.
>>>>>>
>>>>>> Go back to my words and find the error. Every error that you have
>>>>>> found is merely an error in the inaccurate paraphrase of what I said.
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>
>>>>> embedded_H is NOT a UTM
>>>>
>>>> Bzzt you lose, I did not use the term "UTM" in my exact words above.
>>>>
>>>>
>>>
>>> BZZT BACK, LIAR.
>>>
>>> I Said:
>>>
>>>> embedded_H is NOT a UTM
>>
>> And I said the you are only allowed to critique my verbatim words that
>> have no "UTM".
>>
>
> Becasue you use the wrong definition of Halting. PERIOD.
>

There is nothing wrong about it.

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

This is merely Linz applied to a correctly simulated finite string:

the simulated input to embedded_H could never reach its final state in
any finite number of steps of correct simulation by embedded_H

--
Copyright 2022 Pete Olcott

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