On 4/6/2022 6:45 PM, Dennis Bush wrote:
> On Wednesday, April 6, 2022 at 7:35:57 PM UTC-4, olcott wrote:
>> On 4/6/2022 6:33 PM, Dennis Bush wrote:
>>> On Wednesday, April 6, 2022 at 7:11:11 PM UTC-4, olcott wrote:
>>>> On 4/6/2022 6:05 PM, Dennis Bush wrote:
>>>>> On Wednesday, April 6, 2022 at 7:01:31 PM UTC-4, olcott wrote:
>>>>>> On 4/6/2022 5:58 PM, Dennis Bush wrote:
>>>>>>> On Wednesday, April 6, 2022 at 6:53:09 PM UTC-4, olcott wrote:
>>>>>>>> On 4/6/2022 5:48 PM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, April 6, 2022 at 6:12:05 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/6/2022 4:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the last sentence of the following is fully understood it will be
>>>>>>>>>>>>>>>>>> known that I am correct:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WE ALL AGREE ON THIS:
>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>>>>>>>>>> to its own accept or reject state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> HERE IS WHERE WE DIVERGE:
>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>>>>>>>>>> to its own accept or reject state:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On the basis of the actual behavior actually specified by its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> THIS IS EVERYONE'S MISTAKE
>>>>>>>>>>>>>>>>>> All of my reviewers (and Linz) always measure a different sequence of
>>>>>>>>>>>>>>>>>> configurations than the one that is actually specified by the actual
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you understand that different sequences of configurations may have
>>>>>>>>>>>>>>>> different halting behavior from each other?
>>>>>>>>>>>>>>> No an answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Prerequisite order is required.
>>>>>>>>>>>>> What do I need to order?
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When one sequence of configurations seems intuitively identical to
>>>>>>>>>>>>>>>> another sequence then computer science says that their behavior must
>>>>>>>>>>>>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
>>>>>>>>>>>>>>>> SEQUENCES.
>>>>>>>>>>>>>>> Your opinion is noted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is an objectively verifiable fact, not a mere opinion.
>>>>>>>>>>>>> Then there is no reason for you fear answering these two basic but key
>>>>>>>>>>>>> questions:
>>>>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>>>>
>>>>>>>>>>>> You cannot possibly understand my answer to that question until after
>>>>>>>>>>>> you first understand this:
>>>>>>>>>>>
>>>>>>>>>>> No, you can't post the answer because you know it will show you are
>>>>>>>>>>> wrong.
>>>>>>>>>>>
>>>>>>>>>>> And, seriously, what do you think could make me not understand the
>>>>>>>>>>> answer? It's a string. How complicated it is? What you mean is that I
>>>>>>>>>>> can't possibly understand /that your answer is correct/ until I take the
>>>>>>>>>>> blue pill.
>>>>>>>>>> You cannot possibly understand my answer until after you first
>>>>>>>>>> understand that because the correctly simulated input to embedded_H
>>>>>>>>>> cannot possibly reach it own final state, that embedded_H is necessarily
>>>>>>>>>> correct to reject this input and nothing in the whole universe can
>>>>>>>>>> possibly correctly refute this.
>>>>>>>>>
>>>>>>>>> Given Ha3
>>>>>>>> So you change the subject. That is a dishonest thing to do.
>>>>>>>
>>>>>>> Not at all. You stated why you believe embedded_H, or more specifically embedded_Ha,
>>>>>> Not at all. I am not talking about embedded_Ha and you know it.
>>>>>
>>>>> If embedded_H doesn't abort its simulation, that makes it embedded_Hn.
>>>> Bullshit.
>>>>
>>>> The correctly simulated input to embedded_H cannot possibly reach it own
>>>> final state, that embedded_H is necessarily correct to reject this input
>>>> and nothing in the whole universe can possibly correctly refute this.
>>>> Not even your bullshit double-talk.
>>>
>>> So if you believe that, then the following MUST be true by the same logic:
>>>
>>> Given Ha3
>> A agree that you have seemed to be become a liar.
>> I am not talking about Ha3.
>
> So you're avoiding that fact that Ha3

I am avoiding any discussion of anything besides the behavior of
embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

In the future I will simply ignore any of your posts that are not
limited to the topic at hand: embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

--
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 Wednesday, April 6, 2022 at 7:48:56 PM UTC-4, olcott wrote:
> On 4/6/2022 6:45 PM, Dennis Bush wrote:
> > On Wednesday, April 6, 2022 at 7:35:57 PM UTC-4, olcott wrote:
> >> On 4/6/2022 6:33 PM, Dennis Bush wrote:
> >>> On Wednesday, April 6, 2022 at 7:11:11 PM UTC-4, olcott wrote:
> >>>> On 4/6/2022 6:05 PM, Dennis Bush wrote:
> >>>>> On Wednesday, April 6, 2022 at 7:01:31 PM UTC-4, olcott wrote:
> >>>>>> On 4/6/2022 5:58 PM, Dennis Bush wrote:
> >>>>>>> On Wednesday, April 6, 2022 at 6:53:09 PM UTC-4, olcott wrote:
> >>>>>>>> On 4/6/2022 5:48 PM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, April 6, 2022 at 6:12:05 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 4/6/2022 4:25 PM, Ben Bacarisse wrote:
> >>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
> >>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
> >>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> When the last sentence of the following is fully understood it will be
> >>>>>>>>>>>>>>>>>> known that I am correct:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> WE ALL AGREE ON THIS:
> >>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
> >>>>>>>>>>>>>>>>>> to its own accept or reject state.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> HERE IS WHERE WE DIVERGE:
> >>>>>>>>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
> >>>>>>>>>>>>>>>>>> to its own accept or reject state:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On the basis of the actual behavior actually specified by its input.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> THIS IS EVERYONE'S MISTAKE
> >>>>>>>>>>>>>>>>>> All of my reviewers (and Linz) always measure a different sequence of
> >>>>>>>>>>>>>>>>>> configurations than the one that is actually specified by the actual
> >>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
> >>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Do you understand that different sequences of configurations may have
> >>>>>>>>>>>>>>>> different halting behavior from each other?
> >>>>>>>>>>>>>>> No an answer.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Prerequisite order is required.
> >>>>>>>>>>>>> What do I need to order?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> When one sequence of configurations seems intuitively identical to
> >>>>>>>>>>>>>>>> another sequence then computer science says that their behavior must
> >>>>>>>>>>>>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
> >>>>>>>>>>>>>>>> SEQUENCES.
> >>>>>>>>>>>>>>> Your opinion is noted.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> It is an objectively verifiable fact, not a mere opinion.
> >>>>>>>>>>>>> Then there is no reason for you fear answering these two basic but key
> >>>>>>>>>>>>> questions:
> >>>>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
> >>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
> >>>>>>>>>>>>
> >>>>>>>>>>>> You cannot possibly understand my answer to that question until after
> >>>>>>>>>>>> you first understand this:
> >>>>>>>>>>>
> >>>>>>>>>>> No, you can't post the answer because you know it will show you are
> >>>>>>>>>>> wrong.
> >>>>>>>>>>>
> >>>>>>>>>>> And, seriously, what do you think could make me not understand the
> >>>>>>>>>>> answer? It's a string. How complicated it is? What you mean is that I
> >>>>>>>>>>> can't possibly understand /that your answer is correct/ until I take the
> >>>>>>>>>>> blue pill.
> >>>>>>>>>> You cannot possibly understand my answer until after you first
> >>>>>>>>>> understand that because the correctly simulated input to embedded_H
> >>>>>>>>>> cannot possibly reach it own final state, that embedded_H is necessarily
> >>>>>>>>>> correct to reject this input and nothing in the whole universe can
> >>>>>>>>>> possibly correctly refute this.
> >>>>>>>>>
> >>>>>>>>> Given Ha3
> >>>>>>>> So you change the subject. That is a dishonest thing to do.
> >>>>>>>
> >>>>>>> Not at all. You stated why you believe embedded_H, or more specifically embedded_Ha,
> >>>>>> Not at all. I am not talking about embedded_Ha and you know it.
> >>>>>
> >>>>> If embedded_H doesn't abort its simulation, that makes it embedded_Hn.
> >>>> Bullshit.
> >>>>
> >>>> The correctly simulated input to embedded_H cannot possibly reach it own
> >>>> final state, that embedded_H is necessarily correct to reject this input
> >>>> and nothing in the whole universe can possibly correctly refute this..
> >>>> Not even your bullshit double-talk.
> >>>
> >>> So if you believe that, then the following MUST be true by the same logic:
> >>>
> >>> Given Ha3
> >> A agree that you have seemed to be become a liar.
> >> I am not talking about Ha3.
> >
> > So you're avoiding that fact that Ha3
> I am avoiding any discussion of anything besides the behavior of
> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> In the future I will simply ignore any of your posts that are not
> limited to the topic at hand: embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

But if you believe that's correct, you must also believe by the same logic that Ha3 is correct to reject <N><5>, correct?

On 4/6/2022 6:40 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/6/2022 4:25 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> When the last sentence of the following is fully understood it will be
>>>>>>>>>> known that I am correct:
>>>>>>>>>>
>>>>>>>>>> WE ALL AGREE ON THIS:
>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>> to its own accept or reject state.
>>>>>>>>>>
>>>>>>>>>> HERE IS WHERE WE DIVERGE:
>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>> to its own accept or reject state:
>>>>>>>>>>
>>>>>>>>>> On the basis of the actual behavior actually specified by its input.
>>>>>>>>>>
>>>>>>>>>> THIS IS EVERYONE'S MISTAKE
>>>>>>>>>> All of my reviewers (and Linz) always measure a different sequence of
>>>>>>>>>> configurations than the one that is actually specified by the actual
>>>>>>>>>> input.
>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>
>>>>>>>> Do you understand that different sequences of configurations may have
>>>>>>>> different halting behavior from each other?
>>>>>>> No an answer.
>>>>>>
>>>>>> Prerequisite order is required.
>>>>> What do I need to order?
>>>>>
>>>>>>>> When one sequence of configurations seems intuitively identical to
>>>>>>>> another sequence then computer science says that their behavior must
>>>>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
>>>>>>>> SEQUENCES.
>>>>>>> Your opinion is noted.
>>>>>>
>>>>>> It is an objectively verifiable fact, not a mere opinion.
>>>>> Then there is no reason for you fear answering these two basic but key
>>>>> questions:
>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>> applied to ⟨Ĥ⟩ halts?
>>>>
>>>> You cannot possibly understand my answer to that question until after
>>>> you first understand this:
>>> No, you can't post the answer because you know it will show you are
>>> wrong.
>>> And, seriously, what do you think could make me not understand the
>>> answer? It's a string. How complicated it is? What you mean is that I
>>> can't possibly understand /that your answer is correct/ until I take the
>>> blue pill.
>>
>> You cannot possibly understand my answer until after you first
>> understand that because the correctly simulated input to embedded_H
>> cannot possibly reach it own final state, that embedded_H is
>> necessarily correct to reject this input and nothing in the whole
>> universe can possibly correctly refute this.
>
> Thanks. Keep not saying what string must be passed to H so that H can
> tell us whether or not Ĥ applied to ⟨Ĥ⟩

The string passed to embedded_H that it correctly maps to its final
reject state is: ⟨Ĥ⟩ ⟨Ĥ⟩.

It is the case that the correctly simulated input to embedded_H can
never possibly reach its own final state under any condition at all.
Therefore embedded_H is necessarily correct to reject its input.

Maybe you should brush up on modal logic, you don't seem to be able to
grasp what {necessarily} means.

◊P ⟷ ¬□¬P;
Possibly(P) ⟷ Not(Necessarily(Not(P)))

□P ⟷ ¬◊¬P;
Necessarily(P) ⟷ Not(Possibly(Not(P)))

https://en.wikipedia.org/wiki/Modal_logic

--
Copyright 2022 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 4/6/2022 6:40 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/6/2022 4:25 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> When the last sentence of the following is fully understood it will be
>>>>>>>>>>> known that I am correct:
>>>>>>>>>>>
>>>>>>>>>>> WE ALL AGREE ON THIS:
>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>>> to its own accept or reject state.
>>>>>>>>>>>
>>>>>>>>>>> HERE IS WHERE WE DIVERGE:
>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>>> to its own accept or reject state:
>>>>>>>>>>>
>>>>>>>>>>> On the basis of the actual behavior actually specified by its input.
>>>>>>>>>>>
>>>>>>>>>>> THIS IS EVERYONE'S MISTAKE
>>>>>>>>>>> All of my reviewers (and Linz) always measure a different sequence of
>>>>>>>>>>> configurations than the one that is actually specified by the actual
>>>>>>>>>>> input.
>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>
>>>>>>>>> Do you understand that different sequences of configurations may have
>>>>>>>>> different halting behavior from each other?
>>>>>>>> No an answer.
>>>>>>>
>>>>>>> Prerequisite order is required.
>>>>>> What do I need to order?
>>>>>>
>>>>>>>>> When one sequence of configurations seems intuitively identical to
>>>>>>>>> another sequence then computer science says that their behavior must
>>>>>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
>>>>>>>>> SEQUENCES.
>>>>>>>> Your opinion is noted.
>>>>>>>
>>>>>>> It is an objectively verifiable fact, not a mere opinion.
>>>>>> Then there is no reason for you fear answering these two basic but key
>>>>>> questions:
>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>
>>>>> You cannot possibly understand my answer to that question until after
>>>>> you first understand this:
>>>> No, you can't post the answer because you know it will show you are
>>>> wrong.
>>>> And, seriously, what do you think could make me not understand the
>>>> answer? It's a string. How complicated it is? What you mean is that I
>>>> can't possibly understand /that your answer is correct/ until I take the
>>>> blue pill.
>>>
>>> You cannot possibly understand my answer until after you first
>>> understand that because the correctly simulated input to embedded_H
>>> cannot possibly reach it own final state, that embedded_H is
>>> necessarily correct to reject this input and nothing in the whole
>>> universe can possibly correctly refute this.
>>
>> Thanks. Keep not saying what string must be passed to H so that H can
>> tell us whether or not Ĥ applied to ⟨Ĥ⟩
>
> The string passed to embedded_H that it correctly maps to its final
> reject state is: ⟨Ĥ⟩ ⟨Ĥ⟩.

Avoiding the question as always. Thanks.

> It is the case that the correctly simulated input to embedded_H can
> never possibly reach its own final state under any condition at all.
> Therefore embedded_H is necessarily correct to reject its input.

Still avoiding it...

> Maybe you should brush up on modal logic, you don't seem to be able to
> grasp what {necessarily} means.

No thanks. I am happy that you won't answer these questions. The
second one which you keep cutting is: what state does H ⟨Ĥ⟩ ⟨Ĥ⟩
transition to.

--
Ben.

On 4/6/2022 7:22 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/6/2022 6:40 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/6/2022 4:25 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> When the last sentence of the following is fully understood it will be
>>>>>>>>>>>> known that I am correct:
>>>>>>>>>>>>
>>>>>>>>>>>> WE ALL AGREE ON THIS:
>>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>>>> to its own accept or reject state.
>>>>>>>>>>>>
>>>>>>>>>>>> HERE IS WHERE WE DIVERGE:
>>>>>>>>>>>> A halt decider must compute the mapping from its input finite strings
>>>>>>>>>>>> to its own accept or reject state:
>>>>>>>>>>>>
>>>>>>>>>>>> On the basis of the actual behavior actually specified by its input.
>>>>>>>>>>>>
>>>>>>>>>>>> THIS IS EVERYONE'S MISTAKE
>>>>>>>>>>>> All of my reviewers (and Linz) always measure a different sequence of
>>>>>>>>>>>> configurations than the one that is actually specified by the actual
>>>>>>>>>>>> input.
>>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>>
>>>>>>>>>> Do you understand that different sequences of configurations may have
>>>>>>>>>> different halting behavior from each other?
>>>>>>>>> No an answer.
>>>>>>>>
>>>>>>>> Prerequisite order is required.
>>>>>>> What do I need to order?
>>>>>>>
>>>>>>>>>> When one sequence of configurations seems intuitively identical to
>>>>>>>>>> another sequence then computer science says that their behavior must
>>>>>>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
>>>>>>>>>> SEQUENCES.
>>>>>>>>> Your opinion is noted.
>>>>>>>>
>>>>>>>> It is an objectively verifiable fact, not a mere opinion.
>>>>>>> Then there is no reason for you fear answering these two basic but key
>>>>>>> questions:
>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>
>>>>>> You cannot possibly understand my answer to that question until after
>>>>>> you first understand this:
>>>>> No, you can't post the answer because you know it will show you are
>>>>> wrong.
>>>>> And, seriously, what do you think could make me not understand the
>>>>> answer? It's a string. How complicated it is? What you mean is that I
>>>>> can't possibly understand /that your answer is correct/ until I take the
>>>>> blue pill.
>>>>
>>>> You cannot possibly understand my answer until after you first
>>>> understand that because the correctly simulated input to embedded_H
>>>> cannot possibly reach it own final state, that embedded_H is
>>>> necessarily correct to reject this input and nothing in the whole
>>>> universe can possibly correctly refute this.
>>>
>>> Thanks. Keep not saying what string must be passed to H so that H can
>>> tell us whether or not Ĥ applied to ⟨Ĥ⟩
>>
>> The string passed to embedded_H that it correctly maps to its final
>> reject state is: ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Avoiding the question as always. Thanks.
>
>> It is the case that the correctly simulated input to embedded_H can
>> never possibly reach its own final state under any condition at all.
>> Therefore embedded_H is necessarily correct to reject its input.
>
> Still avoiding it...
>
>> Maybe you should brush up on modal logic, you don't seem to be able to
>> grasp what {necessarily} means.
>
> No thanks. I am happy that you won't answer these questions. The
> second one which you keep cutting is: what state does H ⟨Ĥ⟩ ⟨Ĥ⟩
> transition to.
>

It is the case that the correctly simulated input to embedded_H can
never possibly reach its own final state under any condition at all.
Therefore embedded_H is necessarily correct to reject its input.

Since you reject the above maybe you believe that it is possible that X
is a dog is false when X is indeed a dog.

--
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/6/22 10:57 AM, olcott wrote:
> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> When the last sentence of the following is fully understood it
>>>>>>> will be
>>>>>>> known that I am correct:
>>>>>>>
>>>>>>> WE ALL AGREE ON THIS:
>>>>>>> A halt decider must compute the mapping from its input finite
>>>>>>> strings
>>>>>>> to its own accept or reject state.
>>>>>>>
>>>>>>> HERE IS WHERE WE DIVERGE:
>>>>>>> A halt decider must compute the mapping from its input finite
>>>>>>> strings
>>>>>>> to its own accept or reject state:
>>>>>>>
>>>>>>> On the basis of the actual behavior actually specified by its input.
>>>>>>>
>>>>>>> THIS IS EVERYONE'S MISTAKE
>>>>>>> All of my reviewers (and Linz) always measure a different
>>>>>>> sequence of
>>>>>>> configurations than the one that is actually specified by the actual
>>>>>>> input.
>>>>>> What string must be passed to H so that H can tell us whether or
>>>>>> not Ĥ
>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>
>>>>> Do you understand that different sequences of configurations may have
>>>>> different halting behavior from each other?
>>>> No an answer.
>>>
>>> Prerequisite order is required.
>>
>> What do I need to order?
>>
>>>>> When one sequence of configurations seems intuitively identical to
>>>>> another sequence then computer science says that their behavior must
>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
>>>>> SEQUENCES.
>>>> Your opinion is noted.
>>>
>>> It is an objectively verifiable fact, not a mere opinion.
>>
>> Then there is no reason for you fear answering these two basic but key
>> questions:
>>
>> What string must be passed to H so that H can tell us whether or not Ĥ
>> applied to ⟨Ĥ⟩ halts?
>
> You cannot possibly understand my answer to that question until after
> you first understand this:
>
> The actual execution trace of the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
> conclusively proves that it would never reach its own final state under
> any condition what-so-ever thus must be rejected by embedded_H.
>

Except that I HAVE posted a CORRECT simulation of the input string <H^>
<H^> which shows that it DOES reach a final state if embedded_H applied
to <H^> <H^> goes to Qn as you claim it correctly does.

The difference is that YOU think the correct behavior of the input is
the simulation that embedded_H does, even if it aborts it, while I,
using the DEFINITION of correct simulation (per the problem definition)
get the right answer.

You just show that embedded_H is correct at deciding your POOP, not Halting.

FAIL.

On 4/6/22 6:11 PM, olcott wrote:
> On 4/6/2022 4:25 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/6/2022 6:57 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/5/2022 10:42 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/5/2022 9:01 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> When the last sentence of the following is fully understood it
>>>>>>>>> will be
>>>>>>>>> known that I am correct:
>>>>>>>>>
>>>>>>>>> WE ALL AGREE ON THIS:
>>>>>>>>> A halt decider must compute the mapping from its input finite
>>>>>>>>> strings
>>>>>>>>> to its own accept or reject state.
>>>>>>>>>
>>>>>>>>> HERE IS WHERE WE DIVERGE:
>>>>>>>>> A halt decider must compute the mapping from its input finite
>>>>>>>>> strings
>>>>>>>>> to its own accept or reject state:
>>>>>>>>>
>>>>>>>>> On the basis of the actual behavior actually specified by its
>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> THIS IS EVERYONE'S MISTAKE
>>>>>>>>> All of my reviewers (and Linz) always measure a different
>>>>>>>>> sequence of
>>>>>>>>> configurations than the one that is actually specified by the
>>>>>>>>> actual
>>>>>>>>> input.
>>>>>>>> What string must be passed to H so that H can tell us whether or
>>>>>>>> not Ĥ
>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>
>>>>>>> Do you understand that different sequences of configurations may
>>>>>>> have
>>>>>>> different halting behavior from each other?
>>>>>> No an answer.
>>>>>
>>>>> Prerequisite order is required.
>>>> What do I need to order?
>>>>
>>>>>>> When one sequence of configurations seems intuitively identical to
>>>>>>> another sequence then computer science says that their behavior must
>>>>>>> be the same UNLESS INTUITION IS WRONG AND THEY ARE DIFFERENT
>>>>>>> SEQUENCES.
>>>>>> Your opinion is noted.
>>>>>
>>>>> It is an objectively verifiable fact, not a mere opinion.
>>>> Then there is no reason for you fear answering these two basic but key
>>>> questions:
>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>> applied to ⟨Ĥ⟩ halts?
>>>
>>> You cannot possibly understand my answer to that question until after
>>> you first understand this:
>>
>> No, you can't post the answer because you know it will show you are
>> wrong.
>>
>> And, seriously, what do you think could make me not understand the
>> answer?  It's a string.  How complicated it is?  What you mean is that I
>> can't possibly understand /that your answer is correct/ until I take the
>> blue pill.
>
> You cannot possibly understand my answer until after you first
> understand that because the correctly simulated input to embedded_H
> cannot possibly reach it own final state, that embedded_H is necessarily
> correct to reject this input and nothing in the whole universe can
> possibly correctly refute this.

WRONG

>
> Here is a simpler case of that same kind of reasoning:
> If X is a dog, then anyone that disagrees is necessarily incorrect.
>

Except you don't have the dog, you just have its POOP.

On 4/6/22 10:54 AM, olcott wrote:
> On 4/6/2022 3:42 AM, Mikko wrote:
>> On 2022-04-05 21:57:37 +0000, olcott said:
>>
>>> When the last sentence of the following is fully understood it will
>>> be known that I am correct:
>>>
>>> WE ALL AGREE ON THIS:
>>> A halt decider must compute the mapping from its input finite strings
>>> to its own accept or reject state.
>>
>> This tells that a halt decider must be a decider but does not tell
>> how a halt decider differs from any other decider.
>>
>>> HERE IS WHERE WE DIVERGE:
>>> A halt decider must compute the mapping from its input finite strings
>>> to its own accept or reject state:
>>>
>>> On the basis of the actual behavior actually specified by its input.
>>
>> The last line is too vague, and there is no point in an agreement about
>> words without an agreement about the meaning of those words.
>> In particular, the word "specified" does not specify what interpretation
>> of the input gives the "specified" behaviour.
>>
>>> THIS IS EVERYONE'S MISTAKE
>>> All of my reviewers (and Linz) always measure a different sequence of
>>> configurations than the one that is actually specified by the actual
>>> input.
>>
>> No, it is not a mistake. The exact meaning of "specified" is left vague.
>> Therefore there can be different correct interpretations.
>>
>> Mikko
>>
>
> The actual execution trace of the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
> conclusively proves that it would never reach its own final state under
> any condition what-so-ever thus must be rejected by embedded_H.
>

Nope, the a actual CORRECT execution trace of the simulation of the
input shows that it DOES halt if embedded_H goes to Qn.

You are using the WRONG definition, so you get the WRONG answer.

You just either are LYING about what you are doing or are too dumb to
know the difference.

On 2022-04-06 14:54:27 +0000, olcott said:

> The actual execution trace of the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to
> embedded_H conclusively proves that it would never reach its own final
> state under any condition what-so-ever thus must be rejected by
> embedded_H.

That does not contradict what I said.

Anyway, a finite execution trace cannot prove that the execution
is infinite. An infinite trace does not prove anything, as proofs
must be finite. Therefore no execution trace can prove that an
execution is infinite.

Mikko

On 4/7/2022 8:34 AM, Mikko wrote:
> On 2022-04-06 14:54:27 +0000, olcott said:
>
>> The actual execution trace of the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to
>> embedded_H conclusively proves that it would never reach its own final
>> state under any condition what-so-ever thus must be rejected by
>> embedded_H.
>
> That does not contradict what I said.
>
> Anyway, a finite execution trace cannot prove that the execution
> is infinite.

Yes it can and here is an example:

_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]

> An infinite trace does not prove anything, as proofs
> must be finite. Therefore no execution trace can prove that an
> execution is infinite.
>
> Mikko
>

--
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 2022-04-07 14:32:39 +0000, olcott said:

> On 4/7/2022 8:34 AM, Mikko wrote:

>> Anyway, a finite execution trace cannot prove that the execution
>> is infinite.
>
> Yes it can and here is an example:
>
> _Infinite_Loop()
> [00000946](01) 55 push ebp
> [00000947](02) 8bec mov ebp,esp
> [00000949](02) ebfe jmp 00000949
> [0000094b](01) 5d pop ebp
> [0000094c](01) c3 ret
> Size in bytes:(0007) [0000094c]

That trace alone does not prove that an execution never ends. It can be
a part of a proof, but the proof must contain other assumptions. For
example, when started, the CPU does not start at 00000946, so something
has happened before that instruction was executed. Therefore the proof
must show (or assume) that the execution before that address did not
start a timer so that a time-out interrupt would abort the execution.

Mikko

On 4/8/2022 3:55 AM, Mikko wrote:
> On 2022-04-07 14:32:39 +0000, olcott said:
>
>> On 4/7/2022 8:34 AM, Mikko wrote:
>
>>> Anyway, a finite execution trace cannot prove that the execution
>>> is infinite.
>>
>> Yes it can and here is an example:
>>
>> _Infinite_Loop()
>> [00000946](01)  55              push ebp
>> [00000947](02)  8bec            mov ebp,esp
>> [00000949](02)  ebfe            jmp 00000949
>> [0000094b](01)  5d              pop ebp
>> [0000094c](01)  c3              ret
>> Size in bytes:(0007) [0000094c]
>
> That trace alone does not prove that an execution never ends. It can be
> a part of a proof, but the proof must contain other assumptions. For
> example, when started, the CPU does not start at 00000946, so something
> has happened before that instruction was executed. Therefore the proof
> must show (or assume) that the execution before that address did not
> start a timer so that a time-out interrupt would abort the execution.
>
> Mikko
>

None-the-less a finite trace of the above code does prove that it never
halts.

--
Copyright 2022 Pete Olcott

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