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.

--
Copyright 2022 Pete Olcott

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