On Wednesday, 5 January 2022 at 23:36:36 UTC+1, olcott wrote:
> On 1/5/2022 4:27 PM, Julio Di Egidio wrote:
> > On Wednesday, 5 January 2022 at 15:46:41 UTC+1, malcolm.ar...@gmail.com wrote:
> >> On Wednesday, 5 January 2022 at 14:31:17 UTC, olcott wrote:
> >>> On 1/5/2022 5:01 AM, Julio Di Egidio wrote:
> >>>> On Wednesday, 5 January 2022 at 06:34:32 UTC+1, richar...@gmail.com wrote:
> >>>>> On 1/4/22 11:15 PM, olcott wrote:
> >>>>>> On 1/4/2022 10:09 PM, Richard Damon wrote:
> >>>>>>> On 1/4/22 10:43 PM, olcott wrote:
> >>>>>>>> On 1/4/2022 8:04 PM, Richard Damon wrote:
> >>>>>>>>> On 1/4/22 7:29 PM, olcott wrote:
> >>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
> >>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:
> >>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
> >>>>
> >>>>> FAIL.
> >>>>
> >>>> STOP FEEDING THE TROLLS: you fucking retarded spamming pieces of shit are the true disgrace here.
> >>>>
> >>>> *Plonk*
> >>>>
> >>> Dumb Bunny !!!
> >>>
> >>> Plonk is a Usenet jargon term for adding a particular poster to one's
> >>> kill file so that poster's future postings are completely ignored.
> >>> https://news.ycombinator.com/item?id=26890646
> >>>
> >> Julio has added Richard to his kill file, because he is annoyed by his responses
> >> to you. The "plonk" suggests that other people do the same.
> >
> > I am cursing *years* of flooding this and every channel with just fucking bullshit.
> >
> > ESAD all of you pieces of retarded shit and plain agents of the enemy.
> >
> > *Plonk*
> >
> After all these years yo don't even know what the work "Plonk" means.

It means ESAD olcott, you spamming piece of shit, you and all the retarded cunts who are the other side of the same coin.

*Plonk*

Julio

On 1/5/2022 4:15 PM, Richard Damon wrote:
> On 1/5/22 4:01 PM, olcott wrote:
>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>> On 1/5/22 3:41 PM, olcott wrote:
>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:
>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>> function H
>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>> simulation.
>>>>>>>>>>>> Simple question: Since virtually everyone who has studied
>>>>>>>>>>>> this problem
>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt decider
>>>>>>>>>>>> (assuming one could be built). The proof you are attacking
>>>>>>>>>>>> as well as
>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
>>>>>>>>>>>> insist that
>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>
>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>
>>>>>>>>>>> The first observation is that a simulating halt decider goes
>>>>>>>>>>> into an
>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So this
>>>>>>>>>>> leads to the
>>>>>>>>>>> question, can we somehow exploit this to get round the Linz
>>>>>>>>>>> trap?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are the only reviewer that has ever made any attempt at an
>>>>>>>>>> honest dialogue. (Except possibly Kaz) That one party of a
>>>>>>>>>> conversation has no intention of any honest dialogue is proven
>>>>>>>>>> by the fact that there are persistently zero elements of
>>>>>>>>>> mutual agreement by one of the parties.
>>>>>>>>>>
>>>>>>>>>> Every time that I effectively prove my point those respondents
>>>>>>>>>> that have no interest what-so-ever in any honest dialogue
>>>>>>>>>> always change the subject to another basis of rebuttal.
>>>>>>>>>>
>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>
>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>> language determines thought and that linguistic categories
>>>>>>>>>> limit and determine cognitive categories.
>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>
>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>> decision on the behavior of simulating N steps of their input
>>>>>>>>>> until this input either halts on its own or the TM recognizes
>>>>>>>>>> an infinitely behavior pattern we must have a term.
>>>>>>>>>>
>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
>>>>>>>>>
>>>>>>>>> But since the Theorem that you want to actually talk about is
>>>>>>>>> based on the term Decider, you can't change the meaning of the
>>>>>>>>> term or use a slightly different term and still be talking
>>>>>>>>> about THAT Theorem.
>>>>>>>>>
>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The most straight forward way to qualify such a term would be
>>>>>>>>>> that a TM is a simulating halt decider that computes the halt
>>>>>>>>>> status of a limited domain of finite string pairs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>> include the string that represents the description of the H^
>>>>>>>>> machine build on your exact H being applied to that string.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, that is the only element of the domain of the simulating
>>>>>>>> halt decider hat I am referring to.
>>>>>>>>
>>>>>>>>>> H computes the function of mapping input pairs to an accept /
>>>>>>>>>> reject state on the basis of simulating N steps of this input
>>>>>>>>>> pair until this simulated input reaches its final state or H
>>>>>>>>>> has recognize an infinite behavior pattern. Because the
>>>>>>>>>> purpose of H is limited to showing how the conventional HP
>>>>>>>>>> counter-examples would be decided the function that H computes
>>>>>>>>>> its limited to one element of these counter-example inputs.
>>>>>>>>>
>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this accept/reject
>>>>>>>>> needs to match the ACTUAL BEHAVIOR of that H^ machine built
>>>>>>>>> from the H you are claiming to be correct applied to its
>>>>>>>>> description.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>> embedded_H would never reach the final state of this simulated
>>>>>>>> input then it would be  known with 100% perfectly justified
>>>>>>>> complete logical certainty that this input specifies a
>>>>>>>> non-halting computation.
>>>>>>>
>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
>>>>>>> reach the final state, then this MEANS that since H^ USES H, that
>>>>>>> H, which is IDENTICAL to this one, must never abort its
>>>>>>> simulation and go to H.Qn, thus you premise is that H never goes
>>>>>>> to H.Qn.
>>>>>>>
>>>>>>
>>>>>> This might seem this way to a brain dead moron that can't begin to
>>>>>> imagine that a simulating halt decider could recognize that
>>>>>> something as simple as an infinite loop would never stop running
>>>>>> unless this simulating halt decider actually waited an infinite
>>>>>> amount of time to verify that the infinite loop never stops running.
>>>>>>
>>>>>> Are you really a brain dead moron or merely pretending to be one
>>>>>> as a vicious head game?
>>>>>
>>>>> You may see me as 'Brain Dead', but you are the one who seems to
>>>>> not be able to read what people say and make an appropriate response.
>>>>>
>>>>> If you think this task is so easy, just show your code that does it.
>>>>>
>>>>
>>>> One need not see any code when one knows that when the invocation of
>>>> a function results in the invocation of this same function with the
>>>> same inputs that this proves infinite behavior.
>>>>
>>>>  From what I recall this was your own idea that you now deceitfully
>>>> deny.
>>>
>>> Yes, INVOCATION of the same function in a CALL chain will generate
>>> infinite behavior,
>>>
>>> If H 'calls' its input (maybe by UTM Simulation) this would be the
>>> behavior, but such an H then has lost the ability to 'abort' the
>>> 'simulation' to return the answer.
>>>
>>
>> You and Ben both deny that a halt decider could have simulating
>> ability, this is so ridiculously stupid that it must be flat out
>> dishonesty.
>
> LIE!!!
>
> I never said that, please show where I did or retract it.
>
> Maybe I should have a solicitor pay you a call with a defamation suit.
>
> Maybe if you had to try to explain your logic to a jury under penalty of
> perjury you would shape up.
>
>>
>> Since I have a fully operational halt decider that does have
>> simulating ability this proves that you are a damned liar.
>
> But it doesn't give the right answer, so YOU are the damned liar.
>

On Wednesday, 5 January 2022 at 23:43:52 UTC+1, olcott wrote:
> On 1/5/2022 4:15 PM, Richard Damon wrote:
> > On 1/5/22 4:01 PM, olcott wrote:
> >> On 1/5/2022 2:55 PM, Richard Damon wrote:
> >>> On 1/5/22 3:41 PM, olcott wrote:
> >>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
> >>>>> On 1/5/22 3:03 PM, olcott wrote:
> >>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
> >>>>>>> On 1/5/22 1:00 PM, olcott wrote:
> >>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
> >>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
> >>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
> >>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:
> >>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
> >>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
> >>>>>>>>>>>>> function H
> >>>>>>>>>>>>> correctly detects that P specifies infinitely nested
> >>>>>>>>>>>>> simulation.
> >>>>>>>>>>>> Simple question: Since virtually everyone who has studied
> >>>>>>>>>>>> this problem
> >>>>>>>>>>>> knows, simulation is not a feasible way to build a halt decider
> >>>>>>>>>>>> (assuming one could be built). The proof you are attacking
> >>>>>>>>>>>> as well as
> >>>>>>>>>>>> others I am aware of are not based on simulation. Why do
> >>>>>>>>>>>> insist that
> >>>>>>>>>>>> simulation is the way to go?
> >>>>>>>>>>>>
> >>>>>>>>>>> I think I can answer this for PO.
> >>>>>>>>>>>
> >>>>>>>>>>> The first observation is that a simulating halt decider goes
> >>>>>>>>>>> into an
> >>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So this
> >>>>>>>>>>> leads to the
> >>>>>>>>>>> question, can we somehow exploit this to get round the Linz
> >>>>>>>>>>> trap?
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> You are the only reviewer that has ever made any attempt at an
> >>>>>>>>>> honest dialogue. (Except possibly Kaz) That one party of a
> >>>>>>>>>> conversation has no intention of any honest dialogue is proven
> >>>>>>>>>> by the fact that there are persistently zero elements of
> >>>>>>>>>> mutual agreement by one of the parties.
> >>>>>>>>>>
> >>>>>>>>>> Every time that I effectively prove my point those respondents
> >>>>>>>>>> that have no interest what-so-ever in any honest dialogue
> >>>>>>>>>> always change the subject to another basis of rebuttal.
> >>>>>>>>>>
> >>>>>>>>>> When Ben responded to your point he studiously totally
> >>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
> >>>>>>>>>>
> >>>>>>>>>> Sapir–Whorf hypothesis
> >>>>>>>>>> language determines thought and that linguistic categories
> >>>>>>>>>> limit and determine cognitive categories.
> >>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
> >>>>>>>>>>
> >>>>>>>>>> In order to talk about TMs that base their halt status
> >>>>>>>>>> decision on the behavior of simulating N steps of their input
> >>>>>>>>>> until this input either halts on its own or the TM recognizes
> >>>>>>>>>> an infinitely behavior pattern we must have a term.
> >>>>>>>>>>
> >>>>>>>>>> Since the term "decider" must halt on all inputs, the term
> >>>>>>>>>> decider may not be perfectly apt unless we qualify it.
> >>>>>>>>>
> >>>>>>>>> But since the Theorem that you want to actually talk about is
> >>>>>>>>> based on the term Decider, you can't change the meaning of the
> >>>>>>>>> term or use a slightly different term and still be talking
> >>>>>>>>> about THAT Theorem.
> >>>>>>>>>
> >>>>>>>>> You don't get to 'change' the meaning of the terms in the
> >>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> The most straight forward way to qualify such a term would be
> >>>>>>>>>> that a TM is a simulating halt decider that computes the halt
> >>>>>>>>>> status of a limited domain of finite string pairs.
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> And to do the job you claim to be doing that domain MUST
> >>>>>>>>> include the string that represents the description of the H^
> >>>>>>>>> machine build on your exact H being applied to that string.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Yes, that is the only element of the domain of the simulating
> >>>>>>>> halt decider hat I am referring to.
> >>>>>>>>
> >>>>>>>>>> H computes the function of mapping input pairs to an accept /
> >>>>>>>>>> reject state on the basis of simulating N steps of this input
> >>>>>>>>>> pair until this simulated input reaches its final state or H
> >>>>>>>>>> has recognize an infinite behavior pattern. Because the
> >>>>>>>>>> purpose of H is limited to showing how the conventional HP
> >>>>>>>>>> counter-examples would be decided the function that H computes
> >>>>>>>>>> its limited to one element of these counter-example inputs.
> >>>>>>>>>
> >>>>>>>>> And to meet the REQUIREMENTS of the Theory, this accept/reject
> >>>>>>>>> needs to match the ACTUAL BEHAVIOR of that H^ machine built
> >>>>>>>>> from the H you are claiming to be correct applied to its
> >>>>>>>>> description.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
> >>>>>>>> embedded_H would never reach the final state of this simulated
> >>>>>>>> input then it would be known with 100% perfectly justified
> >>>>>>>> complete logical certainty that this input specifies a
> >>>>>>>> non-halting computation.
> >>>>>>>
> >>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
> >>>>>>> reach the final state, then this MEANS that since H^ USES H, that
> >>>>>>> H, which is IDENTICAL to this one, must never abort its
> >>>>>>> simulation and go to H.Qn, thus you premise is that H never goes
> >>>>>>> to H.Qn.
> >>>>>>>
> >>>>>>
> >>>>>> This might seem this way to a brain dead moron that can't begin to
> >>>>>> imagine that a simulating halt decider could recognize that
> >>>>>> something as simple as an infinite loop would never stop running
> >>>>>> unless this simulating halt decider actually waited an infinite
> >>>>>> amount of time to verify that the infinite loop never stops running.
> >>>>>>
> >>>>>> Are you really a brain dead moron or merely pretending to be one
> >>>>>> as a vicious head game?
> >>>>>
> >>>>> You may see me as 'Brain Dead', but you are the one who seems to
> >>>>> not be able to read what people say and make an appropriate response.
> >>>>>
> >>>>> If you think this task is so easy, just show your code that does it..
> >>>>>
> >>>>
> >>>> One need not see any code when one knows that when the invocation of
> >>>> a function results in the invocation of this same function with the
> >>>> same inputs that this proves infinite behavior.
> >>>>
> >>>> From what I recall this was your own idea that you now deceitfully
> >>>> deny.
> >>>
> >>> Yes, INVOCATION of the same function in a CALL chain will generate
> >>> infinite behavior,
> >>>
> >>> If H 'calls' its input (maybe by UTM Simulation) this would be the
> >>> behavior, but such an H then has lost the ability to 'abort' the
> >>> 'simulation' to return the answer.
> >>>
> >>
> >> You and Ben both deny that a halt decider could have simulating
> >> ability, this is so ridiculously stupid that it must be flat out
> >> dishonesty.
> >
> > LIE!!!
> >
> > I never said that, please show where I did or retract it.
> >
> > Maybe I should have a solicitor pay you a call with a defamation suit.
> >
> > Maybe if you had to try to explain your logic to a jury under penalty of
> > perjury you would shape up.
> >
> >>
> >> Since I have a fully operational halt decider that does have
> >> simulating ability this proves that you are a damned liar.
> >
> > But it doesn't give the right answer, so YOU are the damned liar.
> >
> You are simply too stupid to know what the right answer is.
> > If your H says that P(P) will not halt, then when the running of P(P)
> > per the requrements shows that P(P) Halts, this is PROOF that your H was
> > wrong.
> >
> > FAIL.
> This is the damned lie of the fallacy of equivocation error. The input
> to H never halts. The halting decider is only accountable for the
> behavior of its input.
>
> As soon as the halt decider correctly determines that no amount of
> simulation will ever cause its input to reach the final state of this
> input it has 100% complete proof that this input specifies a non-halting
> computation.
> --
> Copyright 2021 Pete Olcott

On 1/5/2022 4:43 PM, Julio Di Egidio wrote:
> On Wednesday, 5 January 2022 at 23:36:36 UTC+1, olcott wrote:
>> On 1/5/2022 4:27 PM, Julio Di Egidio wrote:
>>> On Wednesday, 5 January 2022 at 15:46:41 UTC+1, malcolm.ar...@gmail.com wrote:
>>>> On Wednesday, 5 January 2022 at 14:31:17 UTC, olcott wrote:
>>>>> On 1/5/2022 5:01 AM, Julio Di Egidio wrote:
>>>>>> On Wednesday, 5 January 2022 at 06:34:32 UTC+1, richar...@gmail.com wrote:
>>>>>>> On 1/4/22 11:15 PM, olcott wrote:
>>>>>>>> On 1/4/2022 10:09 PM, Richard Damon wrote:
>>>>>>>>> On 1/4/22 10:43 PM, olcott wrote:
>>>>>>>>>> On 1/4/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/4/22 7:29 PM, olcott wrote:
>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:
>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> STOP FEEDING THE TROLLS: you fucking retarded spamming pieces of shit are the true disgrace here.
>>>>>>
>>>>>> *Plonk*
>>>>>>
>>>>> Dumb Bunny !!!
>>>>>
>>>>> Plonk is a Usenet jargon term for adding a particular poster to one's
>>>>> kill file so that poster's future postings are completely ignored.
>>>>> https://news.ycombinator.com/item?id=26890646
>>>>>
>>>> Julio has added Richard to his kill file, because he is annoyed by his responses
>>>> to you. The "plonk" suggests that other people do the same.
>>>
>>> I am cursing *years* of flooding this and every channel with just fucking bullshit.
>>>
>>> ESAD all of you pieces of retarded shit and plain agents of the enemy.
>>>
>>> *Plonk*
>>>
>> After all these years yo don't even know what the work "Plonk" means.
>
> It means ESAD olcott, you spamming piece of shit, you and all the retarded cunts who are the other side of the same coin.
>
> *Plonk*
>
> Julio

IT MEANS THAT YOU NEVER SEE ANY OF MY MESSAGES EVER AGAIN
IT MEANS THAT YOU NEVER SEE ANY OF MY MESSAGES EVER AGAIN
IT MEANS THAT YOU NEVER SEE ANY OF MY MESSAGES EVER AGAIN
IT MEANS THAT YOU NEVER SEE ANY OF MY MESSAGES EVER AGAIN
IT MEANS THAT YOU NEVER SEE ANY OF MY MESSAGES EVER AGAIN

--
Copyright 2021 Pete Olcott

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

On 1/5/22 5:43 PM, olcott wrote:
> On 1/5/2022 4:15 PM, Richard Damon wrote:
>> On 1/5/22 4:01 PM, olcott wrote:
>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>> Simple question: Since virtually everyone who has studied
>>>>>>>>>>>>> this problem
>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt
>>>>>>>>>>>>> decider
>>>>>>>>>>>>> (assuming one could be built). The proof you are attacking
>>>>>>>>>>>>> as well as
>>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
>>>>>>>>>>>>> insist that
>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>
>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>
>>>>>>>>>>>> The first observation is that a simulating halt decider goes
>>>>>>>>>>>> into an
>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So this
>>>>>>>>>>>> leads to the
>>>>>>>>>>>> question, can we somehow exploit this to get round the Linz
>>>>>>>>>>>> trap?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You are the only reviewer that has ever made any attempt at
>>>>>>>>>>> an honest dialogue. (Except possibly Kaz) That one party of a
>>>>>>>>>>> conversation has no intention of any honest dialogue is
>>>>>>>>>>> proven by the fact that there are persistently zero elements
>>>>>>>>>>> of mutual agreement by one of the parties.
>>>>>>>>>>>
>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>> respondents that have no interest what-so-ever in any honest
>>>>>>>>>>> dialogue always change the subject to another basis of rebuttal.
>>>>>>>>>>>
>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>
>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>> language determines thought and that linguistic categories
>>>>>>>>>>> limit and determine cognitive categories.
>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>
>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>> decision on the behavior of simulating N steps of their input
>>>>>>>>>>> until this input either halts on its own or the TM recognizes
>>>>>>>>>>> an infinitely behavior pattern we must have a term.
>>>>>>>>>>>
>>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
>>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>
>>>>>>>>>> But since the Theorem that you want to actually talk about is
>>>>>>>>>> based on the term Decider, you can't change the meaning of the
>>>>>>>>>> term or use a slightly different term and still be talking
>>>>>>>>>> about THAT Theorem.
>>>>>>>>>>
>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The most straight forward way to qualify such a term would be
>>>>>>>>>>> that a TM is a simulating halt decider that computes the halt
>>>>>>>>>>> status of a limited domain of finite string pairs.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>> include the string that represents the description of the H^
>>>>>>>>>> machine build on your exact H being applied to that string.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, that is the only element of the domain of the simulating
>>>>>>>>> halt decider hat I am referring to.
>>>>>>>>>
>>>>>>>>>>> H computes the function of mapping input pairs to an accept /
>>>>>>>>>>> reject state on the basis of simulating N steps of this input
>>>>>>>>>>> pair until this simulated input reaches its final state or H
>>>>>>>>>>> has recognize an infinite behavior pattern. Because the
>>>>>>>>>>> purpose of H is limited to showing how the conventional HP
>>>>>>>>>>> counter-examples would be decided the function that H
>>>>>>>>>>> computes its limited to one element of these counter-example
>>>>>>>>>>> inputs.
>>>>>>>>>>
>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this accept/reject
>>>>>>>>>> needs to match the ACTUAL BEHAVIOR of that H^ machine built
>>>>>>>>>> from the H you are claiming to be correct applied to its
>>>>>>>>>> description.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>> embedded_H would never reach the final state of this simulated
>>>>>>>>> input then it would be  known with 100% perfectly justified
>>>>>>>>> complete logical certainty that this input specifies a
>>>>>>>>> non-halting computation.
>>>>>>>>
>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
>>>>>>>> reach the final state, then this MEANS that since H^ USES H,
>>>>>>>> that H, which is IDENTICAL to this one, must never abort its
>>>>>>>> simulation and go to H.Qn, thus you premise is that H never goes
>>>>>>>> to H.Qn.
>>>>>>>>
>>>>>>>
>>>>>>> This might seem this way to a brain dead moron that can't begin
>>>>>>> to imagine that a simulating halt decider could recognize that
>>>>>>> something as simple as an infinite loop would never stop running
>>>>>>> unless this simulating halt decider actually waited an infinite
>>>>>>> amount of time to verify that the infinite loop never stops running.
>>>>>>>
>>>>>>> Are you really a brain dead moron or merely pretending to be one
>>>>>>> as a vicious head game?
>>>>>>
>>>>>> You may see me as 'Brain Dead', but you are the one who seems to
>>>>>> not be able to read what people say and make an appropriate response.
>>>>>>
>>>>>> If you think this task is so easy, just show your code that does it.
>>>>>>
>>>>>
>>>>> One need not see any code when one knows that when the invocation
>>>>> of a function results in the invocation of this same function with
>>>>> the same inputs that this proves infinite behavior.
>>>>>
>>>>>  From what I recall this was your own idea that you now deceitfully
>>>>> deny.
>>>>
>>>> Yes, INVOCATION of the same function in a CALL chain will generate
>>>> infinite behavior,
>>>>
>>>> If H 'calls' its input (maybe by UTM Simulation) this would be the
>>>> behavior, but such an H then has lost the ability to 'abort' the
>>>> 'simulation' to return the answer.
>>>>
>>>
>>> You and Ben both deny that a halt decider could have simulating
>>> ability, this is so ridiculously stupid that it must be flat out
>>> dishonesty.
>>
>> LIE!!!
>>
>> I never said that, please show where I did or retract it.
>>
>> Maybe I should have a solicitor pay you a call with a defamation suit.
>>
>> Maybe if you had to try to explain your logic to a jury under penalty
>> of perjury you would shape up.
>>
>>>
>>> Since I have a fully operational halt decider that does have
>>> simulating ability this proves that you are a damned liar.
>>
>> But it doesn't give the right answer, so YOU are the damned liar.
>>
>
> You are simply too stupid to know what the right answer is.

On 1/5/2022 4:44 PM, Julio Di Egidio wrote:
> On Wednesday, 5 January 2022 at 23:43:52 UTC+1, olcott wrote:
>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>> On 1/5/22 4:01 PM, olcott wrote:
>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:
>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>> Simple question: Since virtually everyone who has studied
>>>>>>>>>>>>>> this problem
>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt decider
>>>>>>>>>>>>>> (assuming one could be built). The proof you are attacking
>>>>>>>>>>>>>> as well as
>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
>>>>>>>>>>>>>> insist that
>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The first observation is that a simulating halt decider goes
>>>>>>>>>>>>> into an
>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So this
>>>>>>>>>>>>> leads to the
>>>>>>>>>>>>> question, can we somehow exploit this to get round the Linz
>>>>>>>>>>>>> trap?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are the only reviewer that has ever made any attempt at an
>>>>>>>>>>>> honest dialogue. (Except possibly Kaz) That one party of a
>>>>>>>>>>>> conversation has no intention of any honest dialogue is proven
>>>>>>>>>>>> by the fact that there are persistently zero elements of
>>>>>>>>>>>> mutual agreement by one of the parties.
>>>>>>>>>>>>
>>>>>>>>>>>> Every time that I effectively prove my point those respondents
>>>>>>>>>>>> that have no interest what-so-ever in any honest dialogue
>>>>>>>>>>>> always change the subject to another basis of rebuttal.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>>
>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>> language determines thought and that linguistic categories
>>>>>>>>>>>> limit and determine cognitive categories.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>
>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>> decision on the behavior of simulating N steps of their input
>>>>>>>>>>>> until this input either halts on its own or the TM recognizes
>>>>>>>>>>>> an infinitely behavior pattern we must have a term.
>>>>>>>>>>>>
>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
>>>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>>
>>>>>>>>>>> But since the Theorem that you want to actually talk about is
>>>>>>>>>>> based on the term Decider, you can't change the meaning of the
>>>>>>>>>>> term or use a slightly different term and still be talking
>>>>>>>>>>> about THAT Theorem.
>>>>>>>>>>>
>>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The most straight forward way to qualify such a term would be
>>>>>>>>>>>> that a TM is a simulating halt decider that computes the halt
>>>>>>>>>>>> status of a limited domain of finite string pairs.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>> include the string that represents the description of the H^
>>>>>>>>>>> machine build on your exact H being applied to that string.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, that is the only element of the domain of the simulating
>>>>>>>>>> halt decider hat I am referring to.
>>>>>>>>>>
>>>>>>>>>>>> H computes the function of mapping input pairs to an accept /
>>>>>>>>>>>> reject state on the basis of simulating N steps of this input
>>>>>>>>>>>> pair until this simulated input reaches its final state or H
>>>>>>>>>>>> has recognize an infinite behavior pattern. Because the
>>>>>>>>>>>> purpose of H is limited to showing how the conventional HP
>>>>>>>>>>>> counter-examples would be decided the function that H computes
>>>>>>>>>>>> its limited to one element of these counter-example inputs.
>>>>>>>>>>>
>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this accept/reject
>>>>>>>>>>> needs to match the ACTUAL BEHAVIOR of that H^ machine built
>>>>>>>>>>> from the H you are claiming to be correct applied to its
>>>>>>>>>>> description.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>> embedded_H would never reach the final state of this simulated
>>>>>>>>>> input then it would be known with 100% perfectly justified
>>>>>>>>>> complete logical certainty that this input specifies a
>>>>>>>>>> non-halting computation.
>>>>>>>>>
>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
>>>>>>>>> reach the final state, then this MEANS that since H^ USES H, that
>>>>>>>>> H, which is IDENTICAL to this one, must never abort its
>>>>>>>>> simulation and go to H.Qn, thus you premise is that H never goes
>>>>>>>>> to H.Qn.
>>>>>>>>>
>>>>>>>>
>>>>>>>> This might seem this way to a brain dead moron that can't begin to
>>>>>>>> imagine that a simulating halt decider could recognize that
>>>>>>>> something as simple as an infinite loop would never stop running
>>>>>>>> unless this simulating halt decider actually waited an infinite
>>>>>>>> amount of time to verify that the infinite loop never stops running.
>>>>>>>>
>>>>>>>> Are you really a brain dead moron or merely pretending to be one
>>>>>>>> as a vicious head game?
>>>>>>>
>>>>>>> You may see me as 'Brain Dead', but you are the one who seems to
>>>>>>> not be able to read what people say and make an appropriate response.
>>>>>>>
>>>>>>> If you think this task is so easy, just show your code that does it.
>>>>>>>
>>>>>>
>>>>>> One need not see any code when one knows that when the invocation of
>>>>>> a function results in the invocation of this same function with the
>>>>>> same inputs that this proves infinite behavior.
>>>>>>
>>>>>> From what I recall this was your own idea that you now deceitfully
>>>>>> deny.
>>>>>
>>>>> Yes, INVOCATION of the same function in a CALL chain will generate
>>>>> infinite behavior,
>>>>>
>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be the
>>>>> behavior, but such an H then has lost the ability to 'abort' the
>>>>> 'simulation' to return the answer.
>>>>>
>>>>
>>>> You and Ben both deny that a halt decider could have simulating
>>>> ability, this is so ridiculously stupid that it must be flat out
>>>> dishonesty.
>>>
>>> LIE!!!
>>>
>>> I never said that, please show where I did or retract it.
>>>
>>> Maybe I should have a solicitor pay you a call with a defamation suit.
>>>
>>> Maybe if you had to try to explain your logic to a jury under penalty of
>>> perjury you would shape up.
>>>
>>>>
>>>> Since I have a fully operational halt decider that does have
>>>> simulating ability this proves that you are a damned liar.
>>>
>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>
>> You are simply too stupid to know what the right answer is.
>>> If your H says that P(P) will not halt, then when the running of P(P)
>>> per the requrements shows that P(P) Halts, this is PROOF that your H was
>>> wrong.
>>>
>>> FAIL.
>> This is the damned lie of the fallacy of equivocation error. The input
>> to H never halts. The halting decider is only accountable for the
>> behavior of its input.
>>
>> As soon as the halt decider correctly determines that no amount of
>> simulation will ever cause its input to reach the final state of this
>> input it has 100% complete proof that this input specifies a non-halting
>> computation.
>> --
>> Copyright 2021 Pete Olcott
>
> ESAD olcott, you spamming piece of shit, you and the retarded cunts who are the other side of the same coin.
>
> *Plonk*
>
> Julio

On Wednesday, January 5, 2022 at 1:01:17 PM UTC-8, olcott wrote:

.. . . l have a fully operational halt decider . . .

Publish it ASAP! People are in need of it.

On 1/5/2022 5:10 PM, Richard Damon wrote:
> On 1/5/22 5:43 PM, olcott wrote:
>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>> On 1/5/22 4:01 PM, olcott wrote:
>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>> Simple question: Since virtually everyone who has studied
>>>>>>>>>>>>>> this problem
>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt
>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>> (assuming one could be built). The proof you are attacking
>>>>>>>>>>>>>> as well as
>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
>>>>>>>>>>>>>> insist that
>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The first observation is that a simulating halt decider
>>>>>>>>>>>>> goes into an
>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So this
>>>>>>>>>>>>> leads to the
>>>>>>>>>>>>> question, can we somehow exploit this to get round the Linz
>>>>>>>>>>>>> trap?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are the only reviewer that has ever made any attempt at
>>>>>>>>>>>> an honest dialogue. (Except possibly Kaz) That one party of
>>>>>>>>>>>> a conversation has no intention of any honest dialogue is
>>>>>>>>>>>> proven by the fact that there are persistently zero elements
>>>>>>>>>>>> of mutual agreement by one of the parties.
>>>>>>>>>>>>
>>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>>> respondents that have no interest what-so-ever in any honest
>>>>>>>>>>>> dialogue always change the subject to another basis of
>>>>>>>>>>>> rebuttal.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>>
>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>> language determines thought and that linguistic categories
>>>>>>>>>>>> limit and determine cognitive categories.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>
>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>> decision on the behavior of simulating N steps of their
>>>>>>>>>>>> input until this input either halts on its own or the TM
>>>>>>>>>>>> recognizes an infinitely behavior pattern we must have a term.
>>>>>>>>>>>>
>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
>>>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>>
>>>>>>>>>>> But since the Theorem that you want to actually talk about is
>>>>>>>>>>> based on the term Decider, you can't change the meaning of
>>>>>>>>>>> the term or use a slightly different term and still be
>>>>>>>>>>> talking about THAT Theorem.
>>>>>>>>>>>
>>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The most straight forward way to qualify such a term would
>>>>>>>>>>>> be that a TM is a simulating halt decider that computes the
>>>>>>>>>>>> halt status of a limited domain of finite string pairs.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>> include the string that represents the description of the H^
>>>>>>>>>>> machine build on your exact H being applied to that string.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, that is the only element of the domain of the simulating
>>>>>>>>>> halt decider hat I am referring to.
>>>>>>>>>>
>>>>>>>>>>>> H computes the function of mapping input pairs to an accept
>>>>>>>>>>>> / reject state on the basis of simulating N steps of this
>>>>>>>>>>>> input pair until this simulated input reaches its final
>>>>>>>>>>>> state or H has recognize an infinite behavior pattern.
>>>>>>>>>>>> Because the purpose of H is limited to showing how the
>>>>>>>>>>>> conventional HP counter-examples would be decided the
>>>>>>>>>>>> function that H computes its limited to one element of these
>>>>>>>>>>>> counter-example inputs.
>>>>>>>>>>>
>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this
>>>>>>>>>>> accept/reject needs to match the ACTUAL BEHAVIOR of that H^
>>>>>>>>>>> machine built from the H you are claiming to be correct
>>>>>>>>>>> applied to its description.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>> embedded_H would never reach the final state of this simulated
>>>>>>>>>> input then it would be  known with 100% perfectly justified
>>>>>>>>>> complete logical certainty that this input specifies a
>>>>>>>>>> non-halting computation.
>>>>>>>>>
>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
>>>>>>>>> reach the final state, then this MEANS that since H^ USES H,
>>>>>>>>> that H, which is IDENTICAL to this one, must never abort its
>>>>>>>>> simulation and go to H.Qn, thus you premise is that H never
>>>>>>>>> goes to H.Qn.
>>>>>>>>>
>>>>>>>>
>>>>>>>> This might seem this way to a brain dead moron that can't begin
>>>>>>>> to imagine that a simulating halt decider could recognize that
>>>>>>>> something as simple as an infinite loop would never stop running
>>>>>>>> unless this simulating halt decider actually waited an infinite
>>>>>>>> amount of time to verify that the infinite loop never stops
>>>>>>>> running.
>>>>>>>>
>>>>>>>> Are you really a brain dead moron or merely pretending to be one
>>>>>>>> as a vicious head game?
>>>>>>>
>>>>>>> You may see me as 'Brain Dead', but you are the one who seems to
>>>>>>> not be able to read what people say and make an appropriate
>>>>>>> response.
>>>>>>>
>>>>>>> If you think this task is so easy, just show your code that does it.
>>>>>>>
>>>>>>
>>>>>> One need not see any code when one knows that when the invocation
>>>>>> of a function results in the invocation of this same function with
>>>>>> the same inputs that this proves infinite behavior.
>>>>>>
>>>>>>  From what I recall this was your own idea that you now
>>>>>> deceitfully deny.
>>>>>
>>>>> Yes, INVOCATION of the same function in a CALL chain will generate
>>>>> infinite behavior,
>>>>>
>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be the
>>>>> behavior, but such an H then has lost the ability to 'abort' the
>>>>> 'simulation' to return the answer.
>>>>>
>>>>
>>>> You and Ben both deny that a halt decider could have simulating
>>>> ability, this is so ridiculously stupid that it must be flat out
>>>> dishonesty.
>>>
>>> LIE!!!
>>>
>>> I never said that, please show where I did or retract it.
>>>
>>> Maybe I should have a solicitor pay you a call with a defamation suit.
>>>
>>> Maybe if you had to try to explain your logic to a jury under penalty
>>> of perjury you would shape up.
>>>
>>>>
>>>> Since I have a fully operational halt decider that does have
>>>> simulating ability this proves that you are a damned liar.
>>>
>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>
>>
>> You are simply too stupid to know what the right answer is.
>
> No, I know that BY THE DEFINITION, since H -> H.Qn thus H^ -> H^.Qn and
> Halts, that the Halting behavior is Halting.
>
>>
>>> If your H says that P(P) will not halt, then when the running of P(P)
>>> per the requrements shows that P(P) Halts, this is PROOF that your H
>>> was wrong.
>>>
>>> FAIL.
>>
>> This is the damned lie of the fallacy of equivocation error. The input
>> to H never halts. The halting decider is only accountable for the
>> behavior of its input.
>
> No, YOU do that, you have several different things that you call H, with
> different behaviors.
>

On 1/5/22 6:22 PM, olcott wrote:
> On 1/5/2022 5:10 PM, Richard Damon wrote:
>> On 1/5/22 5:43 PM, olcott wrote:
>>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>>> On 1/5/22 4:01 PM, olcott wrote:
>>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>> Simple question: Since virtually everyone who has studied
>>>>>>>>>>>>>>> this problem
>>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt
>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>> (assuming one could be built). The proof you are
>>>>>>>>>>>>>>> attacking as well as
>>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
>>>>>>>>>>>>>>> insist that
>>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The first observation is that a simulating halt decider
>>>>>>>>>>>>>> goes into an
>>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So
>>>>>>>>>>>>>> this leads to the
>>>>>>>>>>>>>> question, can we somehow exploit this to get round the
>>>>>>>>>>>>>> Linz trap?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are the only reviewer that has ever made any attempt at
>>>>>>>>>>>>> an honest dialogue. (Except possibly Kaz) That one party of
>>>>>>>>>>>>> a conversation has no intention of any honest dialogue is
>>>>>>>>>>>>> proven by the fact that there are persistently zero
>>>>>>>>>>>>> elements of mutual agreement by one of the parties.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>>>> respondents that have no interest what-so-ever in any
>>>>>>>>>>>>> honest dialogue always change the subject to another basis
>>>>>>>>>>>>> of rebuttal.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>>> language determines thought and that linguistic categories
>>>>>>>>>>>>> limit and determine cognitive categories.
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>>
>>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>>> decision on the behavior of simulating N steps of their
>>>>>>>>>>>>> input until this input either halts on its own or the TM
>>>>>>>>>>>>> recognizes an infinitely behavior pattern we must have a term.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
>>>>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>>>
>>>>>>>>>>>> But since the Theorem that you want to actually talk about
>>>>>>>>>>>> is based on the term Decider, you can't change the meaning
>>>>>>>>>>>> of the term or use a slightly different term and still be
>>>>>>>>>>>> talking about THAT Theorem.
>>>>>>>>>>>>
>>>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The most straight forward way to qualify such a term would
>>>>>>>>>>>>> be that a TM is a simulating halt decider that computes the
>>>>>>>>>>>>> halt status of a limited domain of finite string pairs.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>>> include the string that represents the description of the H^
>>>>>>>>>>>> machine build on your exact H being applied to that string.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, that is the only element of the domain of the simulating
>>>>>>>>>>> halt decider hat I am referring to.
>>>>>>>>>>>
>>>>>>>>>>>>> H computes the function of mapping input pairs to an accept
>>>>>>>>>>>>> / reject state on the basis of simulating N steps of this
>>>>>>>>>>>>> input pair until this simulated input reaches its final
>>>>>>>>>>>>> state or H has recognize an infinite behavior pattern.
>>>>>>>>>>>>> Because the purpose of H is limited to showing how the
>>>>>>>>>>>>> conventional HP counter-examples would be decided the
>>>>>>>>>>>>> function that H computes its limited to one element of
>>>>>>>>>>>>> these counter-example inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this
>>>>>>>>>>>> accept/reject needs to match the ACTUAL BEHAVIOR of that H^
>>>>>>>>>>>> machine built from the H you are claiming to be correct
>>>>>>>>>>>> applied to its description.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>> embedded_H would never reach the final state of this
>>>>>>>>>>> simulated input then it would be  known with 100% perfectly
>>>>>>>>>>> justified complete logical certainty that this input
>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>
>>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
>>>>>>>>>> reach the final state, then this MEANS that since H^ USES H,
>>>>>>>>>> that H, which is IDENTICAL to this one, must never abort its
>>>>>>>>>> simulation and go to H.Qn, thus you premise is that H never
>>>>>>>>>> goes to H.Qn.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This might seem this way to a brain dead moron that can't begin
>>>>>>>>> to imagine that a simulating halt decider could recognize that
>>>>>>>>> something as simple as an infinite loop would never stop
>>>>>>>>> running unless this simulating halt decider actually waited an
>>>>>>>>> infinite amount of time to verify that the infinite loop never
>>>>>>>>> stops running.
>>>>>>>>>
>>>>>>>>> Are you really a brain dead moron or merely pretending to be
>>>>>>>>> one as a vicious head game?
>>>>>>>>
>>>>>>>> You may see me as 'Brain Dead', but you are the one who seems to
>>>>>>>> not be able to read what people say and make an appropriate
>>>>>>>> response.
>>>>>>>>
>>>>>>>> If you think this task is so easy, just show your code that does
>>>>>>>> it.
>>>>>>>>
>>>>>>>
>>>>>>> One need not see any code when one knows that when the invocation
>>>>>>> of a function results in the invocation of this same function
>>>>>>> with the same inputs that this proves infinite behavior.
>>>>>>>
>>>>>>>  From what I recall this was your own idea that you now
>>>>>>> deceitfully deny.
>>>>>>
>>>>>> Yes, INVOCATION of the same function in a CALL chain will generate
>>>>>> infinite behavior,
>>>>>>
>>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be the
>>>>>> behavior, but such an H then has lost the ability to 'abort' the
>>>>>> 'simulation' to return the answer.
>>>>>>
>>>>>
>>>>> You and Ben both deny that a halt decider could have simulating
>>>>> ability, this is so ridiculously stupid that it must be flat out
>>>>> dishonesty.
>>>>
>>>> LIE!!!
>>>>
>>>> I never said that, please show where I did or retract it.
>>>>
>>>> Maybe I should have a solicitor pay you a call with a defamation suit.
>>>>
>>>> Maybe if you had to try to explain your logic to a jury under
>>>> penalty of perjury you would shape up.
>>>>
>>>>>
>>>>> Since I have a fully operational halt decider that does have
>>>>> simulating ability this proves that you are a damned liar.
>>>>
>>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>>
>>>
>>> You are simply too stupid to know what the right answer is.
>>
>> No, I know that BY THE DEFINITION, since H -> H.Qn thus H^ -> H^.Qn
>> and Halts, that the Halting behavior is Halting.
>>
>>>
>>>> If your H says that P(P) will not halt, then when the running of
>>>> P(P) per the requrements shows that P(P) Halts, this is PROOF that
>>>> your H was wrong.
>>>>
>>>> FAIL.
>>>
>>> This is the damned lie of the fallacy of equivocation error. The
>>> input to H never halts. The halting decider is only accountable for
>>> the behavior of its input.
>>
>> No, YOU do that, you have several different things that you call H,
>> with different behaviors.
>>
>
> It is not that hard.
> (a) H directly executes its input
> (b) H simulates its input
> (c) H watches the simulation of its input looking for infinite behavior
> patterns.

On 1/5/2022 5:36 PM, Richard Damon wrote:
>
> On 1/5/22 6:22 PM, olcott wrote:
>> On 1/5/2022 5:10 PM, Richard Damon wrote:
>>> On 1/5/22 5:43 PM, olcott wrote:
>>>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>>>> On 1/5/22 4:01 PM, olcott wrote:
>>>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>> Simple question: Since virtually everyone who has
>>>>>>>>>>>>>>>> studied this problem
>>>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt
>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>> (assuming one could be built). The proof you are
>>>>>>>>>>>>>>>> attacking as well as
>>>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
>>>>>>>>>>>>>>>> insist that
>>>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The first observation is that a simulating halt decider
>>>>>>>>>>>>>>> goes into an
>>>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So
>>>>>>>>>>>>>>> this leads to the
>>>>>>>>>>>>>>> question, can we somehow exploit this to get round the
>>>>>>>>>>>>>>> Linz trap?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are the only reviewer that has ever made any attempt
>>>>>>>>>>>>>> at an honest dialogue. (Except possibly Kaz) That one
>>>>>>>>>>>>>> party of a conversation has no intention of any honest
>>>>>>>>>>>>>> dialogue is proven by the fact that there are persistently
>>>>>>>>>>>>>> zero elements of mutual agreement by one of the parties.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>>>>> respondents that have no interest what-so-ever in any
>>>>>>>>>>>>>> honest dialogue always change the subject to another basis
>>>>>>>>>>>>>> of rebuttal.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>>>> language determines thought and that linguistic categories
>>>>>>>>>>>>>> limit and determine cognitive categories.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>>>> decision on the behavior of simulating N steps of their
>>>>>>>>>>>>>> input until this input either halts on its own or the TM
>>>>>>>>>>>>>> recognizes an infinitely behavior pattern we must have a
>>>>>>>>>>>>>> term.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
>>>>>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But since the Theorem that you want to actually talk about
>>>>>>>>>>>>> is based on the term Decider, you can't change the meaning
>>>>>>>>>>>>> of the term or use a slightly different term and still be
>>>>>>>>>>>>> talking about THAT Theorem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>>>>> Theorem, no matter how inconvenient that makes things for you.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The most straight forward way to qualify such a term would
>>>>>>>>>>>>>> be that a TM is a simulating halt decider that computes
>>>>>>>>>>>>>> the halt status of a limited domain of finite string pairs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>>>> include the string that represents the description of the
>>>>>>>>>>>>> H^ machine build on your exact H being applied to that string.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, that is the only element of the domain of the
>>>>>>>>>>>> simulating halt decider hat I am referring to.
>>>>>>>>>>>>
>>>>>>>>>>>>>> H computes the function of mapping input pairs to an
>>>>>>>>>>>>>> accept / reject state on the basis of simulating N steps
>>>>>>>>>>>>>> of this input pair until this simulated input reaches its
>>>>>>>>>>>>>> final state or H has recognize an infinite behavior
>>>>>>>>>>>>>> pattern. Because the purpose of H is limited to showing
>>>>>>>>>>>>>> how the conventional HP counter-examples would be decided
>>>>>>>>>>>>>> the function that H computes its limited to one element of
>>>>>>>>>>>>>> these counter-example inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this
>>>>>>>>>>>>> accept/reject needs to match the ACTUAL BEHAVIOR of that H^
>>>>>>>>>>>>> machine built from the H you are claiming to be correct
>>>>>>>>>>>>> applied to its description.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>> embedded_H would never reach the final state of this
>>>>>>>>>>>> simulated input then it would be  known with 100% perfectly
>>>>>>>>>>>> justified complete logical certainty that this input
>>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL
>>>>>>>>>>> never reach the final state, then this MEANS that since H^
>>>>>>>>>>> USES H, that H, which is IDENTICAL to this one, must never
>>>>>>>>>>> abort its simulation and go to H.Qn, thus you premise is that
>>>>>>>>>>> H never goes to H.Qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This might seem this way to a brain dead moron that can't
>>>>>>>>>> begin to imagine that a simulating halt decider could
>>>>>>>>>> recognize that something as simple as an infinite loop would
>>>>>>>>>> never stop running unless this simulating halt decider
>>>>>>>>>> actually waited an infinite amount of time to verify that the
>>>>>>>>>> infinite loop never stops running.
>>>>>>>>>>
>>>>>>>>>> Are you really a brain dead moron or merely pretending to be
>>>>>>>>>> one as a vicious head game?
>>>>>>>>>
>>>>>>>>> You may see me as 'Brain Dead', but you are the one who seems
>>>>>>>>> to not be able to read what people say and make an appropriate
>>>>>>>>> response.
>>>>>>>>>
>>>>>>>>> If you think this task is so easy, just show your code that
>>>>>>>>> does it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> One need not see any code when one knows that when the
>>>>>>>> invocation of a function results in the invocation of this same
>>>>>>>> function with the same inputs that this proves infinite behavior.
>>>>>>>>
>>>>>>>>  From what I recall this was your own idea that you now
>>>>>>>> deceitfully deny.
>>>>>>>
>>>>>>> Yes, INVOCATION of the same function in a CALL chain will
>>>>>>> generate infinite behavior,
>>>>>>>
>>>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be
>>>>>>> the behavior, but such an H then has lost the ability to 'abort'
>>>>>>> the 'simulation' to return the answer.
>>>>>>>
>>>>>>
>>>>>> You and Ben both deny that a halt decider could have simulating
>>>>>> ability, this is so ridiculously stupid that it must be flat out
>>>>>> dishonesty.
>>>>>
>>>>> LIE!!!
>>>>>
>>>>> I never said that, please show where I did or retract it.
>>>>>
>>>>> Maybe I should have a solicitor pay you a call with a defamation suit.
>>>>>
>>>>> Maybe if you had to try to explain your logic to a jury under
>>>>> penalty of perjury you would shape up.
>>>>>
>>>>>>
>>>>>> Since I have a fully operational halt decider that does have
>>>>>> simulating ability this proves that you are a damned liar.
>>>>>
>>>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>>>
>>>>
>>>> You are simply too stupid to know what the right answer is.
>>>
>>> No, I know that BY THE DEFINITION, since H -> H.Qn thus H^ -> H^.Qn
>>> and Halts, that the Halting behavior is Halting.
>>>
>>>>
>>>>> If your H says that P(P) will not halt, then when the running of
>>>>> P(P) per the requrements shows that P(P) Halts, this is PROOF that
>>>>> your H was wrong.
>>>>>
>>>>> FAIL.
>>>>
>>>> This is the damned lie of the fallacy of equivocation error. The
>>>> input to H never halts. The halting decider is only accountable for
>>>> the behavior of its input.
>>>
>>> No, YOU do that, you have several different things that you call H,
>>> with different behaviors.
>>>
>>
>> It is not that hard.
>> (a) H directly executes its input
>> (b) H simulates its input
>> (c) H watches the simulation of its input looking for infinite
>> behavior patterns.
>
> and the complete list of (c) does not exist.

On 1/5/22 7:02 PM, olcott wrote:
> On 1/5/2022 5:36 PM, Richard Damon wrote:
>>
>> On 1/5/22 6:22 PM, olcott wrote:
>>> On 1/5/2022 5:10 PM, Richard Damon wrote:
>>>> On 1/5/22 5:43 PM, olcott wrote:
>>>>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>>>>> On 1/5/22 4:01 PM, olcott wrote:
>>>>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff
>>>>>>>>>>>>>>>> Barnett wrote:
>>>>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>> Simple question: Since virtually everyone who has
>>>>>>>>>>>>>>>>> studied this problem
>>>>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt
>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>> (assuming one could be built). The proof you are
>>>>>>>>>>>>>>>>> attacking as well as
>>>>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why
>>>>>>>>>>>>>>>>> do insist that
>>>>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The first observation is that a simulating halt decider
>>>>>>>>>>>>>>>> goes into an
>>>>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So
>>>>>>>>>>>>>>>> this leads to the
>>>>>>>>>>>>>>>> question, can we somehow exploit this to get round the
>>>>>>>>>>>>>>>> Linz trap?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are the only reviewer that has ever made any attempt
>>>>>>>>>>>>>>> at an honest dialogue. (Except possibly Kaz) That one
>>>>>>>>>>>>>>> party of a conversation has no intention of any honest
>>>>>>>>>>>>>>> dialogue is proven by the fact that there are
>>>>>>>>>>>>>>> persistently zero elements of mutual agreement by one of
>>>>>>>>>>>>>>> the parties.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>>>>>> respondents that have no interest what-so-ever in any
>>>>>>>>>>>>>>> honest dialogue always change the subject to another
>>>>>>>>>>>>>>> basis of rebuttal.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>>>>> language determines thought and that linguistic
>>>>>>>>>>>>>>> categories limit and determine cognitive categories.
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>>>>> decision on the behavior of simulating N steps of their
>>>>>>>>>>>>>>> input until this input either halts on its own or the TM
>>>>>>>>>>>>>>> recognizes an infinitely behavior pattern we must have a
>>>>>>>>>>>>>>> term.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the
>>>>>>>>>>>>>>> term decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But since the Theorem that you want to actually talk about
>>>>>>>>>>>>>> is based on the term Decider, you can't change the meaning
>>>>>>>>>>>>>> of the term or use a slightly different term and still be
>>>>>>>>>>>>>> talking about THAT Theorem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>>>>>> Theorem, no matter how inconvenient that makes things for
>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The most straight forward way to qualify such a term
>>>>>>>>>>>>>>> would be that a TM is a simulating halt decider that
>>>>>>>>>>>>>>> computes the halt status of a limited domain of finite
>>>>>>>>>>>>>>> string pairs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>>>>> include the string that represents the description of the
>>>>>>>>>>>>>> H^ machine build on your exact H being applied to that
>>>>>>>>>>>>>> string.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, that is the only element of the domain of the
>>>>>>>>>>>>> simulating halt decider hat I am referring to.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H computes the function of mapping input pairs to an
>>>>>>>>>>>>>>> accept / reject state on the basis of simulating N steps
>>>>>>>>>>>>>>> of this input pair until this simulated input reaches its
>>>>>>>>>>>>>>> final state or H has recognize an infinite behavior
>>>>>>>>>>>>>>> pattern. Because the purpose of H is limited to showing
>>>>>>>>>>>>>>> how the conventional HP counter-examples would be decided
>>>>>>>>>>>>>>> the function that H computes its limited to one element
>>>>>>>>>>>>>>> of these counter-example inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this
>>>>>>>>>>>>>> accept/reject needs to match the ACTUAL BEHAVIOR of that
>>>>>>>>>>>>>> H^ machine built from the H you are claiming to be correct
>>>>>>>>>>>>>> applied to its description.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>> embedded_H would never reach the final state of this
>>>>>>>>>>>>> simulated input then it would be  known with 100% perfectly
>>>>>>>>>>>>> justified complete logical certainty that this input
>>>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL
>>>>>>>>>>>> never reach the final state, then this MEANS that since H^
>>>>>>>>>>>> USES H, that H, which is IDENTICAL to this one, must never
>>>>>>>>>>>> abort its simulation and go to H.Qn, thus you premise is
>>>>>>>>>>>> that H never goes to H.Qn.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This might seem this way to a brain dead moron that can't
>>>>>>>>>>> begin to imagine that a simulating halt decider could
>>>>>>>>>>> recognize that something as simple as an infinite loop would
>>>>>>>>>>> never stop running unless this simulating halt decider
>>>>>>>>>>> actually waited an infinite amount of time to verify that the
>>>>>>>>>>> infinite loop never stops running.
>>>>>>>>>>>
>>>>>>>>>>> Are you really a brain dead moron or merely pretending to be
>>>>>>>>>>> one as a vicious head game?
>>>>>>>>>>
>>>>>>>>>> You may see me as 'Brain Dead', but you are the one who seems
>>>>>>>>>> to not be able to read what people say and make an appropriate
>>>>>>>>>> response.
>>>>>>>>>>
>>>>>>>>>> If you think this task is so easy, just show your code that
>>>>>>>>>> does it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> One need not see any code when one knows that when the
>>>>>>>>> invocation of a function results in the invocation of this same
>>>>>>>>> function with the same inputs that this proves infinite behavior.
>>>>>>>>>
>>>>>>>>>  From what I recall this was your own idea that you now
>>>>>>>>> deceitfully deny.
>>>>>>>>
>>>>>>>> Yes, INVOCATION of the same function in a CALL chain will
>>>>>>>> generate infinite behavior,
>>>>>>>>
>>>>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be
>>>>>>>> the behavior, but such an H then has lost the ability to 'abort'
>>>>>>>> the 'simulation' to return the answer.
>>>>>>>>
>>>>>>>
>>>>>>> You and Ben both deny that a halt decider could have simulating
>>>>>>> ability, this is so ridiculously stupid that it must be flat out
>>>>>>> dishonesty.
>>>>>>
>>>>>> LIE!!!
>>>>>>
>>>>>> I never said that, please show where I did or retract it.
>>>>>>
>>>>>> Maybe I should have a solicitor pay you a call with a defamation
>>>>>> suit.
>>>>>>
>>>>>> Maybe if you had to try to explain your logic to a jury under
>>>>>> penalty of perjury you would shape up.
>>>>>>
>>>>>>>
>>>>>>> Since I have a fully operational halt decider that does have
>>>>>>> simulating ability this proves that you are a damned liar.
>>>>>>
>>>>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>>>>
>>>>>
>>>>> You are simply too stupid to know what the right answer is.
>>>>
>>>> No, I know that BY THE DEFINITION, since H -> H.Qn thus H^ -> H^.Qn
>>>> and Halts, that the Halting behavior is Halting.
>>>>
>>>>>
>>>>>> If your H says that P(P) will not halt, then when the running of
>>>>>> P(P) per the requrements shows that P(P) Halts, this is PROOF that
>>>>>> your H was wrong.
>>>>>>
>>>>>> FAIL.
>>>>>
>>>>> This is the damned lie of the fallacy of equivocation error. The
>>>>> input to H never halts. The halting decider is only accountable for
>>>>> the behavior of its input.
>>>>
>>>> No, YOU do that, you have several different things that you call H,
>>>> with different behaviors.
>>>>
>>>
>>> It is not that hard.
>>> (a) H directly executes its input
>>> (b) H simulates its input
>>> (c) H watches the simulation of its input looking for infinite
>>> behavior patterns.
>>
>> and the complete list of (c) does not exist.
>
> You know that we do not freaking need an all-knowing version of (c) it
> only needs determine whether or not P halts.
>

On 1/5/2022 5:18 PM, dklei...@gmail.com wrote:
> On Wednesday, January 5, 2022 at 1:01:17 PM UTC-8, olcott wrote:
>
> . . . l have a fully operational halt decider . . .
>
> Publish it ASAP! People are in need of it.

// Simplified Linz(1990) Ĥ
// and Strachey(1965) P
void P(ptr x)
{ ptr y Copy(x);
if (H(x, y))
HERE: goto HERE;
}

The fully operational halt decider only has the machine code of the
above function as the entire domain of the computable function that maps
a pair of these finite strings to the reject state of H.

--
Copyright 2021 Pete Olcott

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

On 1/5/2022 6:27 PM, Richard Damon wrote:
> On 1/5/22 7:02 PM, olcott wrote:
>> On 1/5/2022 5:36 PM, Richard Damon wrote:
>>>
>>> On 1/5/22 6:22 PM, olcott wrote:
>>>> On 1/5/2022 5:10 PM, Richard Damon wrote:
>>>>> On 1/5/22 5:43 PM, olcott wrote:
>>>>>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>>>>>> On 1/5/22 4:01 PM, olcott wrote:
>>>>>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff
>>>>>>>>>>>>>>>>> Barnett wrote:
>>>>>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
>>>>>>>>>>>>>>>>>>> function H
>>>>>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>> Simple question: Since virtually everyone who has
>>>>>>>>>>>>>>>>>> studied this problem
>>>>>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a
>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>> (assuming one could be built). The proof you are
>>>>>>>>>>>>>>>>>> attacking as well as
>>>>>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why
>>>>>>>>>>>>>>>>>> do insist that
>>>>>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The first observation is that a simulating halt decider
>>>>>>>>>>>>>>>>> goes into an
>>>>>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So
>>>>>>>>>>>>>>>>> this leads to the
>>>>>>>>>>>>>>>>> question, can we somehow exploit this to get round the
>>>>>>>>>>>>>>>>> Linz trap?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are the only reviewer that has ever made any attempt
>>>>>>>>>>>>>>>> at an honest dialogue. (Except possibly Kaz) That one
>>>>>>>>>>>>>>>> party of a conversation has no intention of any honest
>>>>>>>>>>>>>>>> dialogue is proven by the fact that there are
>>>>>>>>>>>>>>>> persistently zero elements of mutual agreement by one of
>>>>>>>>>>>>>>>> the parties.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>>>>>>> respondents that have no interest what-so-ever in any
>>>>>>>>>>>>>>>> honest dialogue always change the subject to another
>>>>>>>>>>>>>>>> basis of rebuttal.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>>>>>> language determines thought and that linguistic
>>>>>>>>>>>>>>>> categories limit and determine cognitive categories.
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>>>>>> decision on the behavior of simulating N steps of their
>>>>>>>>>>>>>>>> input until this input either halts on its own or the TM
>>>>>>>>>>>>>>>> recognizes an infinitely behavior pattern we must have a
>>>>>>>>>>>>>>>> term.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the
>>>>>>>>>>>>>>>> term decider may not be perfectly apt unless we qualify it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But since the Theorem that you want to actually talk
>>>>>>>>>>>>>>> about is based on the term Decider, you can't change the
>>>>>>>>>>>>>>> meaning of the term or use a slightly different term and
>>>>>>>>>>>>>>> still be talking about THAT Theorem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
>>>>>>>>>>>>>>> Theorem, no matter how inconvenient that makes things for
>>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The most straight forward way to qualify such a term
>>>>>>>>>>>>>>>> would be that a TM is a simulating halt decider that
>>>>>>>>>>>>>>>> computes the halt status of a limited domain of finite
>>>>>>>>>>>>>>>> string pairs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>>>>>> include the string that represents the description of the
>>>>>>>>>>>>>>> H^ machine build on your exact H being applied to that
>>>>>>>>>>>>>>> string.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, that is the only element of the domain of the
>>>>>>>>>>>>>> simulating halt decider hat I am referring to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H computes the function of mapping input pairs to an
>>>>>>>>>>>>>>>> accept / reject state on the basis of simulating N steps
>>>>>>>>>>>>>>>> of this input pair until this simulated input reaches
>>>>>>>>>>>>>>>> its final state or H has recognize an infinite behavior
>>>>>>>>>>>>>>>> pattern. Because the purpose of H is limited to showing
>>>>>>>>>>>>>>>> how the conventional HP counter-examples would be
>>>>>>>>>>>>>>>> decided the function that H computes its limited to one
>>>>>>>>>>>>>>>> element of these counter-example inputs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this
>>>>>>>>>>>>>>> accept/reject needs to match the ACTUAL BEHAVIOR of that
>>>>>>>>>>>>>>> H^ machine built from the H you are claiming to be
>>>>>>>>>>>>>>> correct applied to its description.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>> embedded_H would never reach the final state of this
>>>>>>>>>>>>>> simulated input then it would be  known with 100%
>>>>>>>>>>>>>> perfectly justified complete logical certainty that this
>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL
>>>>>>>>>>>>> never reach the final state, then this MEANS that since H^
>>>>>>>>>>>>> USES H, that H, which is IDENTICAL to this one, must never
>>>>>>>>>>>>> abort its simulation and go to H.Qn, thus you premise is
>>>>>>>>>>>>> that H never goes to H.Qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> This might seem this way to a brain dead moron that can't
>>>>>>>>>>>> begin to imagine that a simulating halt decider could
>>>>>>>>>>>> recognize that something as simple as an infinite loop would
>>>>>>>>>>>> never stop running unless this simulating halt decider
>>>>>>>>>>>> actually waited an infinite amount of time to verify that
>>>>>>>>>>>> the infinite loop never stops running.
>>>>>>>>>>>>
>>>>>>>>>>>> Are you really a brain dead moron or merely pretending to be
>>>>>>>>>>>> one as a vicious head game?
>>>>>>>>>>>
>>>>>>>>>>> You may see me as 'Brain Dead', but you are the one who seems
>>>>>>>>>>> to not be able to read what people say and make an
>>>>>>>>>>> appropriate response.
>>>>>>>>>>>
>>>>>>>>>>> If you think this task is so easy, just show your code that
>>>>>>>>>>> does it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> One need not see any code when one knows that when the
>>>>>>>>>> invocation of a function results in the invocation of this
>>>>>>>>>> same function with the same inputs that this proves infinite
>>>>>>>>>> behavior.
>>>>>>>>>>
>>>>>>>>>>  From what I recall this was your own idea that you now
>>>>>>>>>> deceitfully deny.
>>>>>>>>>
>>>>>>>>> Yes, INVOCATION of the same function in a CALL chain will
>>>>>>>>> generate infinite behavior,
>>>>>>>>>
>>>>>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be
>>>>>>>>> the behavior, but such an H then has lost the ability to
>>>>>>>>> 'abort' the 'simulation' to return the answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You and Ben both deny that a halt decider could have simulating
>>>>>>>> ability, this is so ridiculously stupid that it must be flat out
>>>>>>>> dishonesty.
>>>>>>>
>>>>>>> LIE!!!
>>>>>>>
>>>>>>> I never said that, please show where I did or retract it.
>>>>>>>
>>>>>>> Maybe I should have a solicitor pay you a call with a defamation
>>>>>>> suit.
>>>>>>>
>>>>>>> Maybe if you had to try to explain your logic to a jury under
>>>>>>> penalty of perjury you would shape up.
>>>>>>>
>>>>>>>>
>>>>>>>> Since I have a fully operational halt decider that does have
>>>>>>>> simulating ability this proves that you are a damned liar.
>>>>>>>
>>>>>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>>>>>
>>>>>>
>>>>>> You are simply too stupid to know what the right answer is.
>>>>>
>>>>> No, I know that BY THE DEFINITION, since H -> H.Qn thus H^ -> H^.Qn
>>>>> and Halts, that the Halting behavior is Halting.
>>>>>
>>>>>>
>>>>>>> If your H says that P(P) will not halt, then when the running of
>>>>>>> P(P) per the requrements shows that P(P) Halts, this is PROOF
>>>>>>> that your H was wrong.
>>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> This is the damned lie of the fallacy of equivocation error. The
>>>>>> input to H never halts. The halting decider is only accountable
>>>>>> for the behavior of its input.
>>>>>
>>>>> No, YOU do that, you have several different things that you call H,
>>>>> with different behaviors.
>>>>>
>>>>
>>>> It is not that hard.
>>>> (a) H directly executes its input
>>>> (b) H simulates its input
>>>> (c) H watches the simulation of its input looking for infinite
>>>> behavior patterns.
>>>
>>> and the complete list of (c) does not exist.
>>
>> You know that we do not freaking need an all-knowing version of (c) it
>> only needs determine whether or not P halts.
>>
>
> Right, and I previously PROVED that there was no finite pattern that H
> could use to determine that H^/P was ACTUALLY Non-Halting, as any
> pattern that H chose would end up being Halting when we actually ran H^/P.
>

On 1/5/22 7:48 PM, olcott wrote:
> On 1/5/2022 6:27 PM, Richard Damon wrote:
>> On 1/5/22 7:02 PM, olcott wrote:
>>> On 1/5/2022 5:36 PM, Richard Damon wrote:
>>>>
>>>> On 1/5/22 6:22 PM, olcott wrote:
>>>>> On 1/5/2022 5:10 PM, Richard Damon wrote:
>>>>>> On 1/5/22 5:43 PM, olcott wrote:
>>>>>>> On 1/5/2022 4:15 PM, Richard Damon wrote:
>>>>>>>> On 1/5/22 4:01 PM, olcott wrote:
>>>>>>>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>>> On 1/5/22 3:41 PM, olcott wrote:
>>>>>>>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/5/22 3:03 PM, olcott wrote:
>>>>>>>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
>>>>>>>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff
>>>>>>>>>>>>>>>>>> Barnett wrote:
>>>>>>>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that
>>>>>>>>>>>>>>>>>>>> pure function H
>>>>>>>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>> Simple question: Since virtually everyone who has
>>>>>>>>>>>>>>>>>>> studied this problem
>>>>>>>>>>>>>>>>>>> knows, simulation is not a feasible way to build a
>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>> (assuming one could be built). The proof you are
>>>>>>>>>>>>>>>>>>> attacking as well as
>>>>>>>>>>>>>>>>>>> others I am aware of are not based on simulation. Why
>>>>>>>>>>>>>>>>>>> do insist that
>>>>>>>>>>>>>>>>>>> simulation is the way to go?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I think I can answer this for PO.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The first observation is that a simulating halt
>>>>>>>>>>>>>>>>>> decider goes into an
>>>>>>>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So
>>>>>>>>>>>>>>>>>> this leads to the
>>>>>>>>>>>>>>>>>> question, can we somehow exploit this to get round the
>>>>>>>>>>>>>>>>>> Linz trap?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are the only reviewer that has ever made any
>>>>>>>>>>>>>>>>> attempt at an honest dialogue. (Except possibly Kaz)
>>>>>>>>>>>>>>>>> That one party of a conversation has no intention of
>>>>>>>>>>>>>>>>> any honest dialogue is proven by the fact that there
>>>>>>>>>>>>>>>>> are persistently zero elements of mutual agreement by
>>>>>>>>>>>>>>>>> one of the parties.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every time that I effectively prove my point those
>>>>>>>>>>>>>>>>> respondents that have no interest what-so-ever in any
>>>>>>>>>>>>>>>>> honest dialogue always change the subject to another
>>>>>>>>>>>>>>>>> basis of rebuttal.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When Ben responded to your point he studiously totally
>>>>>>>>>>>>>>>>> bypassed the point by nitpicking at the use of
>>>>>>>>>>>>>>>>> terminology.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Sapir–Whorf hypothesis
>>>>>>>>>>>>>>>>> language determines thought and that linguistic
>>>>>>>>>>>>>>>>> categories limit and determine cognitive categories.
>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In order to talk about TMs that base their halt status
>>>>>>>>>>>>>>>>> decision on the behavior of simulating N steps of their
>>>>>>>>>>>>>>>>> input until this input either halts on its own or the
>>>>>>>>>>>>>>>>> TM recognizes an infinitely behavior pattern we must
>>>>>>>>>>>>>>>>> have a term.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since the term "decider" must halt on all inputs, the
>>>>>>>>>>>>>>>>> term decider may not be perfectly apt unless we qualify
>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But since the Theorem that you want to actually talk
>>>>>>>>>>>>>>>> about is based on the term Decider, you can't change the
>>>>>>>>>>>>>>>> meaning of the term or use a slightly different term and
>>>>>>>>>>>>>>>> still be talking about THAT Theorem.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You don't get to 'change' the meaning of the terms in
>>>>>>>>>>>>>>>> the Theorem, no matter how inconvenient that makes
>>>>>>>>>>>>>>>> things for you.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The most straight forward way to qualify such a term
>>>>>>>>>>>>>>>>> would be that a TM is a simulating halt decider that
>>>>>>>>>>>>>>>>> computes the halt status of a limited domain of finite
>>>>>>>>>>>>>>>>> string pairs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And to do the job you claim to be doing that domain MUST
>>>>>>>>>>>>>>>> include the string that represents the description of
>>>>>>>>>>>>>>>> the H^ machine build on your exact H being applied to
>>>>>>>>>>>>>>>> that string.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, that is the only element of the domain of the
>>>>>>>>>>>>>>> simulating halt decider hat I am referring to.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H computes the function of mapping input pairs to an
>>>>>>>>>>>>>>>>> accept / reject state on the basis of simulating N
>>>>>>>>>>>>>>>>> steps of this input pair until this simulated input
>>>>>>>>>>>>>>>>> reaches its final state or H has recognize an infinite
>>>>>>>>>>>>>>>>> behavior pattern. Because the purpose of H is limited
>>>>>>>>>>>>>>>>> to showing how the conventional HP counter-examples
>>>>>>>>>>>>>>>>> would be decided the function that H computes its
>>>>>>>>>>>>>>>>> limited to one element of these counter-example inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this
>>>>>>>>>>>>>>>> accept/reject needs to match the ACTUAL BEHAVIOR of that
>>>>>>>>>>>>>>>> H^ machine built from the H you are claiming to be
>>>>>>>>>>>>>>>> correct applied to its description.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>> embedded_H would never reach the final state of this
>>>>>>>>>>>>>>> simulated input then it would be  known with 100%
>>>>>>>>>>>>>>> perfectly justified complete logical certainty that this
>>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL
>>>>>>>>>>>>>> never reach the final state, then this MEANS that since H^
>>>>>>>>>>>>>> USES H, that H, which is IDENTICAL to this one, must never
>>>>>>>>>>>>>> abort its simulation and go to H.Qn, thus you premise is
>>>>>>>>>>>>>> that H never goes to H.Qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This might seem this way to a brain dead moron that can't
>>>>>>>>>>>>> begin to imagine that a simulating halt decider could
>>>>>>>>>>>>> recognize that something as simple as an infinite loop
>>>>>>>>>>>>> would never stop running unless this simulating halt
>>>>>>>>>>>>> decider actually waited an infinite amount of time to
>>>>>>>>>>>>> verify that the infinite loop never stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Are you really a brain dead moron or merely pretending to
>>>>>>>>>>>>> be one as a vicious head game?
>>>>>>>>>>>>
>>>>>>>>>>>> You may see me as 'Brain Dead', but you are the one who
>>>>>>>>>>>> seems to not be able to read what people say and make an
>>>>>>>>>>>> appropriate response.
>>>>>>>>>>>>
>>>>>>>>>>>> If you think this task is so easy, just show your code that
>>>>>>>>>>>> does it.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> One need not see any code when one knows that when the
>>>>>>>>>>> invocation of a function results in the invocation of this
>>>>>>>>>>> same function with the same inputs that this proves infinite
>>>>>>>>>>> behavior.
>>>>>>>>>>>
>>>>>>>>>>>  From what I recall this was your own idea that you now
>>>>>>>>>>> deceitfully deny.
>>>>>>>>>>
>>>>>>>>>> Yes, INVOCATION of the same function in a CALL chain will
>>>>>>>>>> generate infinite behavior,
>>>>>>>>>>
>>>>>>>>>> If H 'calls' its input (maybe by UTM Simulation) this would be
>>>>>>>>>> the behavior, but such an H then has lost the ability to
>>>>>>>>>> 'abort' the 'simulation' to return the answer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You and Ben both deny that a halt decider could have simulating
>>>>>>>>> ability, this is so ridiculously stupid that it must be flat
>>>>>>>>> out dishonesty.
>>>>>>>>
>>>>>>>> LIE!!!
>>>>>>>>
>>>>>>>> I never said that, please show where I did or retract it.
>>>>>>>>
>>>>>>>> Maybe I should have a solicitor pay you a call with a defamation
>>>>>>>> suit.
>>>>>>>>
>>>>>>>> Maybe if you had to try to explain your logic to a jury under
>>>>>>>> penalty of perjury you would shape up.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Since I have a fully operational halt decider that does have
>>>>>>>>> simulating ability this proves that you are a damned liar.
>>>>>>>>
>>>>>>>> But it doesn't give the right answer, so YOU are the damned liar.
>>>>>>>>
>>>>>>>
>>>>>>> You are simply too stupid to know what the right answer is.
>>>>>>
>>>>>> No, I know that BY THE DEFINITION, since H -> H.Qn thus H^ ->
>>>>>> H^.Qn and Halts, that the Halting behavior is Halting.
>>>>>>
>>>>>>>
>>>>>>>> If your H says that P(P) will not halt, then when the running of
>>>>>>>> P(P) per the requrements shows that P(P) Halts, this is PROOF
>>>>>>>> that your H was wrong.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>
>>>>>>> This is the damned lie of the fallacy of equivocation error. The
>>>>>>> input to H never halts. The halting decider is only accountable
>>>>>>> for the behavior of its input.
>>>>>>
>>>>>> No, YOU do that, you have several different things that you call
>>>>>> H, with different behaviors.
>>>>>>
>>>>>
>>>>> It is not that hard.
>>>>> (a) H directly executes its input
>>>>> (b) H simulates its input
>>>>> (c) H watches the simulation of its input looking for infinite
>>>>> behavior patterns.
>>>>
>>>> and the complete list of (c) does not exist.
>>>
>>> You know that we do not freaking need an all-knowing version of (c)
>>> it only needs determine whether or not P halts.
>>>
>>
>> Right, and I previously PROVED that there was no finite pattern that H
>> could use to determine that H^/P was ACTUALLY Non-Halting, as any
>> pattern that H chose would end up being Halting when we actually ran
>> H^/P.
>>
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   ptr y Copy(x);
>   if (H(x, y))
>     HERE: goto HERE;
> }
>
> The fully operational halt decider only has the machine code of the
> above function as the entire domain of the computable function that maps
> a pair of these finite strings to the reject state of H.
>
>

On 1/5/22 7:47 PM, olcott wrote:
> On 1/5/2022 5:18 PM, dklei...@gmail.com wrote:
>> On Wednesday, January 5, 2022 at 1:01:17 PM UTC-8, olcott wrote:
>>
>> . . . l  have a fully operational halt decider . . .
>>
>> Publish it ASAP! People are in need of it.
>
>
> // Simplified Linz(1990) Ĥ
> // and Strachey(1965) P
> void P(ptr x)
> {
>   ptr y Copy(x);
>   if (H(x, y))
>     HERE: goto HERE;
> }
>
> The fully operational halt decider only has the machine code of the
> above function as the entire domain of the computable function that maps
> a pair of these finite strings to the reject state of H.
>

WRONG. FAIL.

On Thursday, 6 January 2022 at 00:17:12 UTC+1, olcott wrote:
> On 1/5/2022 4:44 PM, Julio Di Egidio wrote:
> > On Wednesday, 5 January 2022 at 23:43:52 UTC+1, olcott wrote:
> >> On 1/5/2022 4:15 PM, Richard Damon wrote:
> >>> On 1/5/22 4:01 PM, olcott wrote:
> >>>> On 1/5/2022 2:55 PM, Richard Damon wrote:
> >>>>> On 1/5/22 3:41 PM, olcott wrote:
> >>>>>> On 1/5/2022 2:36 PM, Richard Damon wrote:
> >>>>>>> On 1/5/22 3:03 PM, olcott wrote:
> >>>>>>>> On 1/5/2022 1:54 PM, Richard Damon wrote:
> >>>>>>>>> On 1/5/22 1:00 PM, olcott wrote:
> >>>>>>>>>> On 1/5/2022 10:29 AM, Richard Damon wrote:
> >>>>>>>>>>> On 1/5/22 11:06 AM, olcott wrote:
> >>>>>>>>>>>> On 12/19/2021 4:25 PM, Malcolm McLean wrote:
> >>>>>>>>>>>>> On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:
> >>>>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:
> >>>>>>>>>>>>>>> I can (and will shortly) conclusively prove that pure
> >>>>>>>>>>>>>>> function H
> >>>>>>>>>>>>>>> correctly detects that P specifies infinitely nested
> >>>>>>>>>>>>>>> simulation.
> >>>>>>>>>>>>>> Simple question: Since virtually everyone who has studied
> >>>>>>>>>>>>>> this problem
> >>>>>>>>>>>>>> knows, simulation is not a feasible way to build a halt decider
> >>>>>>>>>>>>>> (assuming one could be built). The proof you are attacking
> >>>>>>>>>>>>>> as well as
> >>>>>>>>>>>>>> others I am aware of are not based on simulation. Why do
> >>>>>>>>>>>>>> insist that
> >>>>>>>>>>>>>> simulation is the way to go?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> I think I can answer this for PO.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The first observation is that a simulating halt decider goes
> >>>>>>>>>>>>> into an
> >>>>>>>>>>>>> infinite series of nested simulations if fed H_Hat. So this
> >>>>>>>>>>>>> leads to the
> >>>>>>>>>>>>> question, can we somehow exploit this to get round the Linz
> >>>>>>>>>>>>> trap?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> You are the only reviewer that has ever made any attempt at an
> >>>>>>>>>>>> honest dialogue. (Except possibly Kaz) That one party of a
> >>>>>>>>>>>> conversation has no intention of any honest dialogue is proven
> >>>>>>>>>>>> by the fact that there are persistently zero elements of
> >>>>>>>>>>>> mutual agreement by one of the parties.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Every time that I effectively prove my point those respondents
> >>>>>>>>>>>> that have no interest what-so-ever in any honest dialogue
> >>>>>>>>>>>> always change the subject to another basis of rebuttal.
> >>>>>>>>>>>>
> >>>>>>>>>>>> When Ben responded to your point he studiously totally
> >>>>>>>>>>>> bypassed the point by nitpicking at the use of terminology.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Sapir–Whorf hypothesis
> >>>>>>>>>>>> language determines thought and that linguistic categories
> >>>>>>>>>>>> limit and determine cognitive categories.
> >>>>>>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
> >>>>>>>>>>>>
> >>>>>>>>>>>> In order to talk about TMs that base their halt status
> >>>>>>>>>>>> decision on the behavior of simulating N steps of their input
> >>>>>>>>>>>> until this input either halts on its own or the TM recognizes
> >>>>>>>>>>>> an infinitely behavior pattern we must have a term.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Since the term "decider" must halt on all inputs, the term
> >>>>>>>>>>>> decider may not be perfectly apt unless we qualify it.
> >>>>>>>>>>>
> >>>>>>>>>>> But since the Theorem that you want to actually talk about is
> >>>>>>>>>>> based on the term Decider, you can't change the meaning of the
> >>>>>>>>>>> term or use a slightly different term and still be talking
> >>>>>>>>>>> about THAT Theorem.
> >>>>>>>>>>>
> >>>>>>>>>>> You don't get to 'change' the meaning of the terms in the
> >>>>>>>>>>> Theorem, no matter how inconvenient that makes things for you..
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> The most straight forward way to qualify such a term would be
> >>>>>>>>>>>> that a TM is a simulating halt decider that computes the halt
> >>>>>>>>>>>> status of a limited domain of finite string pairs.
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> And to do the job you claim to be doing that domain MUST
> >>>>>>>>>>> include the string that represents the description of the H^
> >>>>>>>>>>> machine build on your exact H being applied to that string.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Yes, that is the only element of the domain of the simulating
> >>>>>>>>>> halt decider hat I am referring to.
> >>>>>>>>>>
> >>>>>>>>>>>> H computes the function of mapping input pairs to an accept /
> >>>>>>>>>>>> reject state on the basis of simulating N steps of this input
> >>>>>>>>>>>> pair until this simulated input reaches its final state or H
> >>>>>>>>>>>> has recognize an infinite behavior pattern. Because the
> >>>>>>>>>>>> purpose of H is limited to showing how the conventional HP
> >>>>>>>>>>>> counter-examples would be decided the function that H computes
> >>>>>>>>>>>> its limited to one element of these counter-example inputs.
> >>>>>>>>>>>
> >>>>>>>>>>> And to meet the REQUIREMENTS of the Theory, this accept/reject
> >>>>>>>>>>> needs to match the ACTUAL BEHAVIOR of that H^ machine built
> >>>>>>>>>>> from the H you are claiming to be correct applied to its
> >>>>>>>>>>> description.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
> >>>>>>>>>> embedded_H would never reach the final state of this simulated
> >>>>>>>>>> input then it would be known with 100% perfectly justified
> >>>>>>>>>> complete logical certainty that this input specifies a
> >>>>>>>>>> non-halting computation.
> >>>>>>>>>
> >>>>>>>>> If it is the case that simulation of <H^> <H^> by H WILL never
> >>>>>>>>> reach the final state, then this MEANS that since H^ USES H, that
> >>>>>>>>> H, which is IDENTICAL to this one, must never abort its
> >>>>>>>>> simulation and go to H.Qn, thus you premise is that H never goes
> >>>>>>>>> to H.Qn.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> This might seem this way to a brain dead moron that can't begin to
> >>>>>>>> imagine that a simulating halt decider could recognize that
> >>>>>>>> something as simple as an infinite loop would never stop running
> >>>>>>>> unless this simulating halt decider actually waited an infinite
> >>>>>>>> amount of time to verify that the infinite loop never stops running.
> >>>>>>>>
> >>>>>>>> Are you really a brain dead moron or merely pretending to be one
> >>>>>>>> as a vicious head game?
> >>>>>>>
> >>>>>>> You may see me as 'Brain Dead', but you are the one who seems to
> >>>>>>> not be able to read what people say and make an appropriate response.
> >>>>>>>
> >>>>>>> If you think this task is so easy, just show your code that does it.
> >>>>>>>
> >>>>>>
> >>>>>> One need not see any code when one knows that when the invocation of
> >>>>>> a function results in the invocation of this same function with the
> >>>>>> same inputs that this proves infinite behavior.
> >>>>>>
> >>>>>> From what I recall this was your own idea that you now deceitfully
> >>>>>> deny.
> >>>>>
> >>>>> Yes, INVOCATION of the same function in a CALL chain will generate
> >>>>> infinite behavior,
> >>>>>
> >>>>> If H 'calls' its input (maybe by UTM Simulation) this would be the
> >>>>> behavior, but such an H then has lost the ability to 'abort' the
> >>>>> 'simulation' to return the answer.
> >>>>>
> >>>>
> >>>> You and Ben both deny that a halt decider could have simulating
> >>>> ability, this is so ridiculously stupid that it must be flat out
> >>>> dishonesty.
> >>>
> >>> LIE!!!
> >>>
> >>> I never said that, please show where I did or retract it.
> >>>
> >>> Maybe I should have a solicitor pay you a call with a defamation suit..
> >>>
> >>> Maybe if you had to try to explain your logic to a jury under penalty of
> >>> perjury you would shape up.
> >>>
> >>>>
> >>>> Since I have a fully operational halt decider that does have
> >>>> simulating ability this proves that you are a damned liar.
> >>>
> >>> But it doesn't give the right answer, so YOU are the damned liar.
> >>>
> >> You are simply too stupid to know what the right answer is.
> >>> If your H says that P(P) will not halt, then when the running of P(P)
> >>> per the requrements shows that P(P) Halts, this is PROOF that your H was
> >>> wrong.
> >>>
> >>> FAIL.
> >> This is the damned lie of the fallacy of equivocation error. The input
> >> to H never halts. The halting decider is only accountable for the
> >> behavior of its input.
> >>
> >> As soon as the halt decider correctly determines that no amount of
> >> simulation will ever cause its input to reach the final state of this
> >> input it has 100% complete proof that this input specifies a non-halting
> >> computation.
> >> --
> >> Copyright 2021 Pete Olcott
> >
> > ESAD olcott, you spamming piece of shit, you and the retarded cunts who are the other side of the same coin.
> >
> > *Plonk*
>
> "Plonk" dice al tuo lettore di notizie di ignorare tutti i miei messaggi

On Thursday, 6 January 2022 at 02:16:14 UTC+1, richar...@gmail.com wrote:
> On 1/5/22 7:47 PM, olcott wrote:
> > The fully operational halt decider only has the machine code of the
> > above function as the entire domain of the computable function that maps
> > a pair of these finite strings to the reject state of H.
> >
> WRONG. FAIL.

ESAD, both of you spamming pieces of shit.

*Plonk*

Julio