On 4/2/2022 6:57 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/2/2022 6:07 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/1/2022 7:38 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/1/2022 1:29 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/1/2022 11:38 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>>>>>> I will not discuss your question until after we have mutual agreement
>>>>>>>>>> on all these points because I will not tolerate a one way dialogue
>>>>>>>>>> that only has denigration as feedback.
>>>>>>>>> It's two-way. I ask a simple question: please complete the following
>>>>>>>>> line for me:
>>>>>>>>>
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.q?
>>>>>>>>>
>>>>>>>>> and you reply without answering it. Why don't you say you don't know
>>>>>>>>> the answer to this question as well? That would complete your admission
>>>>>>>>> of knowing almost nothing about the halting problem.
>>>>>>>>>
>>>>>>>>> (It's three times unanswered now.)
>>>>>>>>
>>>>>>>> The following conclusively proves that embedded_H correctly determines
>>>>>>>> the halt status of its input.
>>>>>>>
>>>>>>> Four times unanswered.
>>>>>>>
>>>>>>>> Unless and until we have mutual agreement on these key points
>>>>>>>> (they are the fruition of 17 years worth of work)
>>>>>>>> we cannot move on to your question.
>>>>>>>
>>>>>>> Nothing is stopping you from answering the question. I'm including "I
>>>>>>> don't know" as a possible answer of course.
>>>>>>
>>>>>> MUTUAL AGREEMENT ON THIS IS MANDATORY FOR FURTHER DIALOGUE
>>>>>
>>>>> No it isn't. Not in the passive voice. /You/ may choose not address
>>>>> these questions
>>>>
>>>> Refusing to address questions stops the dialogue,
>>>> The "di" in dialogue means two.
>>> The two of us are exchanging views. You are making unreasonable
>>> demands, and I am asking simple questions that you won't answer. This
>>> is a very informative dialog since it follows the pattern of all crank
>>> threads.
>>>
>>>> MUTUAL AGREEMENT ON THIS IS MANDATORY FOR FURTHER DIALOGUE
>>> Here's where we are. After 17 years work on this you can not even say
>>> what string must be passed to H so that H can tell us whether or not Ĥ
>>> applied to ⟨Ĥ⟩ halts, and you won't say what state H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to even though everyone is happy to accept that
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> from which the answer is easily obtained. It would be extraordinary but
>>> we know what's going on...
>>
>> I did figure out the correct analysis of that.
>> The problem is that the result of the analysis is so counter-intuitive
>> that you will never pay enough attention to see that it is correct.
>
> Good excuse not to say what string must be passed to H so that H can
> tell us whether or not Ĥ applied to ⟨Ĥ⟩ halts and what state H.q0 ⟨Ĥ⟩
> ⟨Ĥ⟩ transitions to!
>
> Keep not answering. What else can you do?

It is very very good and helpful that you brought this question up.
It is a key issue that must be addressed. I have now fully addressed
this issue. I really need to start locking in my progress though.

--
Copyright 2022 Pete Olcott

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

On 4/3/2022 6:26 AM, Richard Damon wrote:
>
> On 4/2/22 11:09 PM, olcott wrote:
>> On 4/2/2022 9:34 PM, Richard Damon wrote:
>>> On 4/2/22 9:53 PM, olcott wrote:
>>>> On 4/2/2022 8:31 PM, Richard Damon wrote:
>>>>> On 4/2/22 9:20 PM, olcott wrote:
>>>>>> On 4/2/2022 8:17 PM, Richard Damon wrote:
>>>>>>> On 4/2/22 9:06 PM, olcott wrote:
>>>>>>>> On 4/2/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>> On 4/2/22 8:36 PM, olcott wrote:
>>>>>>>>>> On 4/2/2022 7:23 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2022-04-02 18:12, olcott wrote:
>>>>>>>>>>>> On 4/2/2022 6:58 PM, André G. Isaak wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if you abort the simulation, the simulation does not
>>>>>>>>>>>>> reach a final state, but it is obvious that if your 'SHD'
>>>>>>>>>>>>> had not aborted the simulation, it *would* have ultimately
>>>>>>>>>>>>> reached a final state.
>>>>>>>>>>>>
>>>>>>>>>>>> So an infinite loop eventually halts if you just wait long
>>>>>>>>>>>> enough.
>>>>>>>>>>>
>>>>>>>>>>> Of course not. But there is no such loop involved in the case
>>>>>>>>>>> under consideration. This is obvious to everyone
>>>>>>>>>>> participating in this thread other than you.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Even Richard knows that this never stops running unless aborted:
>>>>>>>>>>
>>>>>>>>>> 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⟩...
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But the loop isn't an infinite 'Do Loop', so Anre is RIGHT,
>>>>>>>>> there is no infinite Do Loop involved.
>>>>>>>>>
>>>>>>>>> You are just being sloppy.
>>>>>>>>
>>>>>>>> Here is the context of the mistake that I was responding to:
>>>>>>>>
>>>>>>>> On 4/2/2022 6:58 PM, André G. Isaak wrote:
>>>>>>>>  > it is obvious that if your 'SHD' had not aborted the
>>>>>>>>  > simulation, it *would* have ultimately reached a final state.
>>>>>>>>
>>>>>>>> "it *would* have ultimately reached a final state."
>>>>>>>> refers to the simulated input.
>>>>>>>>
>>>>>>>
>>>>>>> But a PROPERLY simulated input WOULD reach the final state.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>
>>>>>> No so much
>>>>>>
>>>>>
>>>>> But that isn't what H^ is.
>>>>
>>>> You are the one that continues to insist that only a UTM can
>>>> properly simulate an input and that this simulated input must never
>>>> be aborted or it becomes an incorrect simulation.
>>>>
>>>>
>>>
>>> Right, but that doesn't mean you put a UTM there. H^ has a copy of H
>>> there (that you are calling embedded_H), so that is wha must be there.
>>>
>>
>> But (according to you) H cannot be there or it will get the simulation
>> wrong.
>>
>>> You are confusing the REQUIREMENTS of H with the algorithm H itself.
>>>
>>> H <M> w needs to go to Qy if M w (or UTM <M> w) will halt and Qn if
>>> it doesn't, but that doesn't mean you get to put a UTM there, because
>>> a UTM doesn't meet the requirements, since it doesn't give the
>>> non-halting answer in finite time.
>>>
>>> H is NOT 'Computationally Equivalent' to a UTM, because its behavior
>>> IS DIFFERENT.
>>>
>>
>> H simulates finite sequences of configurations 100% exactly the same
>> way that a UTM does because it invokes its own internal UTM one step
>> at a time.
>>
>>> For the non-halting case, UTM will be non-halting, but H MUST be a
>>> 'halting computation' that goes to the 'Non-Halting Answer State'
>>>
>>> These are DIFFERENT.
>>>
>>> Is that the confusion what you wasted 17 years on?
>>>
>>> We need to put the actual algorithm of H at the point that was
>>> prevously labled Qx (Linz names it HQ0 to distinguish it from the Q0
>>> starting
>>
>> No he did not: https://www.liarparadox.org/Linz_Proof.pdf
>
> I remembereded his notation wrong. He call the state that is the
> beginning of the orignial code for H starting at q0 with the name H^q0
>
> Which is why the string execution paths are listed as:
>
> q0 wM -> H^q0 wM wM -> H^ infinity [If M applied to wM Halts]
> q0 wM -> H^q0 wM wM -> H^y1Qny2 [If M applied to wM never halts]
>
>
>> My latest notation is much better than his:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>
> Except that you drop the conditions
>

The appended infinite loop is never reached, thus extraneous.

The behavior of the executed Ĥ applied to ⟨Ĥ⟩ still depends depends
conditionally on the behavior of H. This same reasoning applies to UTM
⟨Ĥ⟩ ⟨Ĥ⟩.

The behavior of the input ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by H cannot depend
conditionally on anything because it remains stuck in infinitely nested
simulation until aborted.

>>
>>> state of H^), so that is what is in the representation of H^ there,
>>> the representation of its copy of H, and that is what a UTM will see,
>>> and presumably what your SHD will see.
>>>
>>> The only point we pull out the UTM, is when AS DESIGNERS/TESTERS we
>>> want to check if the answer that H gave was correct.
>>>
>>> And, we are effectively doing that when we are just running H^
>>> applied to <H^>, as that is BY DEFINITION the behavior of UTM <H^> <H^>.
>>>
>>> Yes, one (perhaps you will call UNFAIR) aspect of this is that H
>>> can't just evaluate the requirements to get the right answer, but you
>>> should know from any actually useful programming that rarely can you
>>> just code 'The Requirements' to implement the program, as if you
>>> could, then there would be no need to hire a programmer.
>>>
>>> H can get SOME non-halting cases with a list of patterns, but it
>>> turns out that there is no finite exhaustive list of patterns, which
>>> is why a Halt Decider is not possible (or the answer WOULD be to just
>>> use a SHD with that list of patterns).
>>
>> All patterns are entirely comprised of a small set of elemental
>> patterns this is very well known stuff.
>
> Nope. Care to provide a reference that lists a COMPLETE set of
> non-halting patterns?
>
> Yes, there are a number of basic loops that can become unending, but no
> COMPLETE list (as has been proven).
>

On 4/3/2022 10:24 AM, olcott wrote:
> On 4/3/2022 9:10 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/2/2022 6:57 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/2/2022 6:07 PM, Ben Bacarisse wrote:
>>
>>>>>> Here's where we are.  After 17 years work on this you can not even
>>>>>> say
>>>>>> what string must be passed to H so that H can tell us whether or
>>>>>> not Ĥ
>>>>>> applied to ⟨Ĥ⟩ halts, and you won't say what state H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> transitions to even though everyone is happy to accept that
>>>>>>      Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> from which the answer is easily obtained.  It would be
>>>>>> extraordinary but
>>>>>> we know what's going on...
>>>>>
>>>>> I did figure out the correct analysis of that.
>>>>> The problem is that the result of the analysis is so counter-intuitive
>>>>> that you will never pay enough attention to see that it is correct.
>>>>
>>>> Good excuse not to say what string must be passed to H so that H can
>>>> tell us whether or not Ĥ applied to ⟨Ĥ⟩ halts and what state H.q0 ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ transitions to!
>>>>
>>>> Keep not answering.  What else can you do?
>>>
>>> If you want an honest dialogue you will go through the trouble of
>>> working through mutual agreement on my key points...
>>
>> Mutual agreement on nonsense can never form the basis of any reasonable
>> discussion.
>
> That you can only dogmatically say that it is nonsense and not point out
> any error really seems to prove that you have no idea what I am saying
> because of your lack of technical skill.

I am not saying this as any denigrating put down. I am saying this so
that we will be able to derive a common language and be able to have an
effective dialogue.

You have been my longest reviewer and some aspects of your reviews have
been very helpful. The key question that you ask is very important.
Until we establish a "lingua franca" (common language) between us this
dialogue cannot effectively occur.

KEY MISSING PIECE IN THE DIALOGUE
The key missing piece in all of these dialogues is 100% perfectly and
exactly does it mean for a halt decider to compute the mapping from its
input finite strings to its own final states on the basis of the actual
behavior actually specified by these finite strings.

--
Copyright 2022 Pete Olcott

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