Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Pause for storage relocation.


devel / comp.theory / Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

SubjectAuthor
* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ keyolcott
+- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Python
+- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
 `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |+* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Malcolm McLean
    ||`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    || `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Malcolm McLean
    ||  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    ||   +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    ||   |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    ||   | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    ||   |  `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    ||   `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    | +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    | |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    | | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    | |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    | |   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    | |    `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    | |     `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |    `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |     +- Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |     `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |      +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |      |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |      | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |      |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |      |   `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |      `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |       `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |   +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |   |`- Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |+- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Python
    |   |        |    |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |    `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |     `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Jeff Barnett
    |   |        |    |      |`- Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |      |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |      |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      |   +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Jeff Barnett
    |   |        |    |      |   |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      |   | `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |      |   |  `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      |   |   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |      |   |    `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      |   |     `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |      |   |      `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      |   |       +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |      |   |       |`- Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |      |   |       `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |   |        |    |      |   `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |   |        |    |      `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |       `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |        `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |         `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |          +- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |   |        |    |          `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |           `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |            +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |            |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |            | +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Dennis Bush
    |   |        |    |            | |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |            | | +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Python
    |   |        |    |            | | |`* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |            | | | +- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Python
    |   |        |    |            | | | `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |   |        |    |            | | `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |   |        |    |            | +* Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse
    |   |        |    |            | |`- Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |            | `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Richard Damon
    |   |        |    |            `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |             +- Refuting the Peter Linz Halting Problem Proof --- Version(10) [Malcolm McLean
    |   |        |    |             `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |              `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |               `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    |                `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   |        |    |                 `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        |    `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [olcott
    |   |        `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [André G. Isaak
    |   `* Refuting the Peter Linz Halting Problem Proof --- Version(10) [Andy Walker
    `- Refuting the Peter Linz Halting Problem Proof --- Version(10) [ key missing piecBen Bacarisse

Pages:12345678910111213141516171819202122232425262728293031323334353637383940
Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<IKg4K.443016$SeK9.363249@fx97.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29783&group=comp.theory#29783

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx97.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com> <87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com> <87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com> <87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com> <87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com> <877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com> <87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com> <87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com> <87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com> <87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com> <87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com> <87ee268n4f.fsf@bsb.me.uk>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <87ee268n4f.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 98
Message-ID: <IKg4K.443016$SeK9.363249@fx97.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 10:28:58 -0400
X-Received-Bytes: 6425
 by: Richard Damon - Sat, 9 Apr 2022 14:28 UTC

On 4/9/22 8:20 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>> It is the case that the correctly simulated input to embedded_H can
>>>>>>>>>> never possibly reach its own final state under any condition at all.
>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its input.
>>>>>>>>>
>>>>>>>>> Yet you won't answer two simple questions! Why?
>>>>>>>>
>>>>>>>> Because I absolutely positively will not tolerate divergence from
>>>>>>>> validating my 17 years worth of work.
>>>>>>>
>>>>>>> But you have no choice but to tolerate it. If someone wants to talk
>>>>>>> about why you are wrong, they will do so.
>>>>>>>
>>>>>>> You are wrong (for the C version of H) because H(P,P) == false but P(P)
>>>>>>> halts. You are wrong about your TM H because H <Ĥ> <Ĥ> transitions to
>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free to deny
>>>>>>> any of these facts if the mood takes you.)
>>>>>>
>>>>>> If you believe (against the verified facts) that the simulated ⟨Ĥ0⟩
>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>
>>>>> I believe what you've told me: that you claim that H(P,P)==false is
>>>>> correct despite the fact that P(P) halts. That's wrong.
>>>>
>>>> If the input to H(P,P) cannot possibly reach its final state then this
>>>> input is correctly rejected and nothing in the universe can possibly
>>>> contradict this.
>>>
>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts. You don't dispute
>>> either (indeed they come from you).
>
> At least you don't contend these facts.
>
>>> Your new line in waffle is just an attempt to distract attention from a
>>> very simple claim: that the wrong answer is the right one.
>>
>> Even Linz got this wrong because it is counter-intuitive.
>>
>> A halt decider must compute the mapping from its inputs (not any damn
>> thing else in the universe) to its own final state on the basis of the
>> behavior specified by these inputs
>
> That's not counter intuitive, it's basic. Everyone knows this, though
> it took you a while to get round to it. A halt decider accepts or
> rejects a string based on the behaviour of the computation specified by
> that string. Of course, you never got as far in my exercises as
> specifying any TM that decides something on the basis of behaviour, so
> you really don't know how it's actually done. That was, I thought, the
> whole point of the exercises -- to see how TMs are specified to decide
> properties of computations.
>
>> (thus their simulated execution
>> trace) and not anything else in the universe such as P(P).
>
> Don't be silly. The H/P names refer to your C version in the days
> before you even bothered with strings since they were, in your words,
> "extraneous complexity". In that words, If H has any pretence of being
> a halt decider there must some "input" (i.e. two arguments) that we can
> pass to it so that it's decision will be based of the halting or
> otherwise of P(P). If H can't report about P(P) it's not a halt
> decider.
>

My interpretation of whats going on it Peter's head is that he doesn't
understand to concept of something not existing. He seems to have a
notion that if you can describe something, there must be some way to
make it.

He also seems to understand that A Decider, that exists, can only decide
on a basis that is computable. I think he understands that 'Traditional'
Halting can't actually be computed by an actual Turing Machine, so if we
are talking about a Turing Machine being a Halt Decider, we much change
(slightly) the definition of Halting to something that it can actually
do. Thus the change from 'The behavior of the Actual Machine' (which a
Turing Machine just can't process), to 'The behavior of a UTM' (which it
can sort of handle), to the behavior of the simulator in the decider
while it is in 'UTM Mode' which while not 'exactly' equivalent is close
enough, Sort of like just assuming Pi is 3.14 and saying 'Its Good' even
if you problem needs more precision.

We see this thought process in things like the insistance that there HAS
to be a pattern in the simulation of <H^> <H^> that shows that it will
not halt.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29784&group=comp.theory#29784

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 09:41:56 -0500
Date: Sat, 9 Apr 2022 09:41:54 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87ee268n4f.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 105
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-qQHaDxF4hcTo2AZE04h6Ordv1BLElVsePNlQ03naZI6/DUbDQ+ED4RufaZttNsNyiJg6SQJLU5HC4LV!zuyjkauwszzV/ksK12o/wVw46+pykhCB+Qne4ItLMtqzimjfJfwcNYX0uJ5uuuD5R86PCwpXiDdE!Fw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6635
 by: olcott - Sat, 9 Apr 2022 14:41 UTC

On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>> It is the case that the correctly simulated input to embedded_H can
>>>>>>>>>> never possibly reach its own final state under any condition at all.
>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its input.
>>>>>>>>>
>>>>>>>>> Yet you won't answer two simple questions! Why?
>>>>>>>>
>>>>>>>> Because I absolutely positively will not tolerate divergence from
>>>>>>>> validating my 17 years worth of work.
>>>>>>>
>>>>>>> But you have no choice but to tolerate it. If someone wants to talk
>>>>>>> about why you are wrong, they will do so.
>>>>>>>
>>>>>>> You are wrong (for the C version of H) because H(P,P) == false but P(P)
>>>>>>> halts. You are wrong about your TM H because H <Ĥ> <Ĥ> transitions to
>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free to deny
>>>>>>> any of these facts if the mood takes you.)
>>>>>>
>>>>>> If you believe (against the verified facts) that the simulated ⟨Ĥ0⟩
>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>
>>>>> I believe what you've told me: that you claim that H(P,P)==false is
>>>>> correct despite the fact that P(P) halts. That's wrong.
>>>>
>>>> If the input to H(P,P) cannot possibly reach its final state then this
>>>> input is correctly rejected and nothing in the universe can possibly
>>>> contradict this.
>>>
>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts. You don't dispute
>>> either (indeed they come from you).
>
> At least you don't contend these facts.
>
>>> Your new line in waffle is just an attempt to distract attention from a
>>> very simple claim: that the wrong answer is the right one.
>>
>> Even Linz got this wrong because it is counter-intuitive.
>>
>> A halt decider must compute the mapping from its inputs (not any damn
>> thing else in the universe) to its own final state on the basis of the
>> behavior specified by these inputs
>
> That's not counter intuitive, it's basic. Everyone knows this, though
> it took you a while to get round to it. A halt decider accepts or
> rejects a string based on the behaviour of the computation specified by
> that string. Of course, you never got as far in my exercises as
> specifying any TM that decides something on the basis of behaviour, so
> you really don't know how it's actually done. That was, I thought, the
> whole point of the exercises -- to see how TMs are specified to decide
> properties of computations.
>

You have to actually pay attention to this, it is the key gap in your
reasoning. The following proves that the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
embedded_H cannot possibly reach its own final state under any condition
what-so-ever.

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

When Ĥ is applied to ⟨Ĥ0⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩

Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
non-halting.

>> (thus their simulated execution
>> trace) and not anything else in the universe such as P(P).
>
> Don't be silly. The H/P names refer to your C version in the days
> before you even bothered with strings since they were, in your words,
> "extraneous complexity". In that words, If H has any pretence of being
> a halt decider there must some "input" (i.e. two arguments) that we can
> pass to it so that it's decision will be based of the halting or
> otherwise of P(P). If H can't report about P(P) it's not a halt
> decider.
>

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29785&group=comp.theory#29785

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 09:43:30 -0500
Date: Sat, 9 Apr 2022 09:43:28 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <878rse8mpz.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 30
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4lWjYLBZBOFnxudRjifUq22lzFLw8CQaLkuWuaNAqUs28FlNoDtE8/OrWfd0xYO10NGE6UM7uqvBqRi!lveH3A3knyBF1bcisydiuGGu3kbkailMrd+Ou5hivSAFOmoNMzx3ASx3pEV0KD0GuALQThmu6gzK!TA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3205
 by: olcott - Sat, 9 Apr 2022 14:43 UTC

On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> I tell one tiny piece of the truth until someone gets it. Then I move
>> on to the next tiny piece of the truth until someone gets it.
>
> Oh pull the other one, it's got bells on! Actually, you often tell
> massive whoppers and then spend months backpedalling.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

When Ĥ is applied to ⟨Ĥ0⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩

Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H reaches
its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<esh4K.210689$OT%7.200542@fx07.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29788&group=comp.theory#29788

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx07.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 33
Message-ID: <esh4K.210689$OT%7.200542@fx07.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 11:17:32 -0400
X-Received-Bytes: 3318
 by: Richard Damon - Sat, 9 Apr 2022 15:17 UTC

On 4/9/22 10:43 AM, olcott wrote:
> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> I tell one tiny piece of the truth until someone gets it. Then I move
>>> on to the next tiny piece of the truth until someone gets it.
>>
>> Oh pull the other one, it's got bells on!  Actually, you often tell
>> massive whoppers and then spend months backpedalling.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>
> When Ĥ is applied to ⟨Ĥ0⟩
>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>    H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> Then these steps would keep repeating:
>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>
> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H reaches
> its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>
>

Your right, it doesn't in THAT case, because you have made embedded_H/H
never go to Qn, so it is wrong to begin with.

If you change embedded_H to go to Qn,and you have to change to make that
happen as you have said that pattern goes on forever, then you have a
DIFFERENT H^, which has a different behavior, and THEN the Qn answer is
wrong because THAT H^ will halt.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<bvh4K.56932$Kdf.46756@fx96.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29789&group=comp.theory#29789

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx96.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 122
Message-ID: <bvh4K.56932$Kdf.46756@fx96.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 11:20:40 -0400
X-Received-Bytes: 7124
 by: Richard Damon - Sat, 9 Apr 2022 15:20 UTC

On 4/9/22 10:41 AM, olcott wrote:
> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>> embedded_H can
>>>>>>>>>>> never possibly reach its own final state under any condition
>>>>>>>>>>> at all.
>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its input.
>>>>>>>>>>
>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>
>>>>>>>>> Because I absolutely positively will not tolerate divergence from
>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>
>>>>>>>> But you have no choice but to tolerate it.  If someone wants to
>>>>>>>> talk
>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>
>>>>>>>> You are wrong (for the C version of H) because H(P,P) == false
>>>>>>>> but P(P)
>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>> transitions to
>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free to
>>>>>>>> deny
>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>
>>>>>>> If you believe (against the verified facts) that the simulated ⟨Ĥ0⟩
>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>
>>>>>> I believe what you've told me: that you claim that H(P,P)==false is
>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>
>>>>> If the input to H(P,P) cannot possibly reach its final state then this
>>>>> input is correctly rejected and nothing in the universe can possibly
>>>>> contradict this.
>>>>
>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't dispute
>>>> either (indeed they come from you).
>>
>> At least you don't contend these facts.
>>
>>>> Your new line in waffle is just an attempt to distract attention from a
>>>> very simple claim: that the wrong answer is the right one.
>>>
>>> Even Linz got this wrong because it is counter-intuitive.
>>>
>>> A halt decider must compute the mapping from its inputs (not any damn
>>> thing else in the universe) to its own final state on the basis of the
>>> behavior specified by these inputs
>>
>> That's not counter intuitive, it's basic.  Everyone knows this, though
>> it took you a while to get round to it.  A halt decider accepts or
>> rejects a string based on the behaviour of the computation specified by
>> that string.  Of course, you never got as far in my exercises as
>> specifying any TM that decides something on the basis of behaviour, so
>> you really don't know how it's actually done.  That was, I thought, the
>> whole point of the exercises -- to see how TMs are specified to decide
>> properties of computations.
>>
>
> You have to actually pay attention to this, it is the key gap in your
> reasoning. The following proves that the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
> embedded_H cannot possibly reach its own final state under any condition
> what-so-ever.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>
> When Ĥ is applied to ⟨Ĥ0⟩
>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>    H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> Then these steps would keep repeating:
>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>
> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> non-halting.

Right, if embedded_H never goes to Qn (and ths embedded_H fails to be a
decder) then H^ applied to <H^> is non-halting, but it doesn't matter,
as H was just wrong to begin with.

It you change H / embedded_H to abort and go to Qn, then you don't get
that exact trace (the key words, keep on repeating are no longer true),
and infact the full trace of H^ applied to <H^> shows that it does halt,
so embedded_H / H was wrong.

It is impossible for embedded_H to do both, it can't not abort and make
H^ be non-halting and in the same algorithm abort and go the Qn.

FAIL. LIAR!

>
>>> (thus their simulated execution
>>> trace) and not anything else in the universe such as P(P).
>>
>> Don't be silly.  The H/P names refer to your C version in the days
>> before you even bothered with strings since they were, in your words,
>> "extraneous complexity".  In that words, If H has any pretence of being
>> a halt decider there must some "input" (i.e. two arguments) that we can
>> pass to it so that it's decision will be based of the halting or
>> otherwise of P(P).  If H can't report about P(P) it's not a halt
>> decider.
>>
>
>

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29790&group=comp.theory#29790

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 10:20:59 -0500
Date: Sat, 9 Apr 2022 10:20:57 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <esh4K.210689$OT%7.200542@fx07.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-26tQ8poRMq9bcrlL681bdSS8hLeC64VHsaNlepw8uIwgE6QBF/g8JykV4iwNhCGH3B2r+X6a2SZqJdF!NaQ0nSAhzVNAxrHI5NTXVnrlq+ta32oeASdImjK6Ec3h+Eh7t3KjdRdUSdc1NPUlIGAK3XrWMEnY!Rg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3646
 by: olcott - Sat, 9 Apr 2022 15:20 UTC

On 4/9/2022 10:17 AM, Richard Damon wrote:
> On 4/9/22 10:43 AM, olcott wrote:
>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> I tell one tiny piece of the truth until someone gets it. Then I move
>>>> on to the next tiny piece of the truth until someone gets it.
>>>
>>> Oh pull the other one, it's got bells on!  Actually, you often tell
>>> massive whoppers and then spend months backpedalling.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>
>> When Ĥ is applied to ⟨Ĥ0⟩
>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>> Then these steps would keep repeating:
>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>
>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H reaches
>> its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>
>>
>
> Your right, it doesn't in THAT case,

and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still never
reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29791&group=comp.theory#29791

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 10:25:41 -0500
Date: Sat, 9 Apr 2022 10:25:39 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<bvh4K.56932$Kdf.46756@fx96.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <bvh4K.56932$Kdf.46756@fx96.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 114
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-GcYV9wDC+CyycG8iu999Zl5rDj2n32vNY8k9chYpqW3+qAbox+6SHD4u0LzBgxHzp1ykBmfEz8MRIM/!Y89N9QmTG9ka94IXP9Fa+vpYqUTUDOnMxDPPpDxmGTgtSSa2sD+2UOTblhdYqmOd7WltlE5Ju9cc!6w==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7002
 by: olcott - Sat, 9 Apr 2022 15:25 UTC

On 4/9/2022 10:20 AM, Richard Damon wrote:
> On 4/9/22 10:41 AM, olcott wrote:
>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>> never possibly reach its own final state under any condition
>>>>>>>>>>>> at all.
>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its
>>>>>>>>>>>> input.
>>>>>>>>>>>
>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>
>>>>>>>>>> Because I absolutely positively will not tolerate divergence from
>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>
>>>>>>>>> But you have no choice but to tolerate it.  If someone wants to
>>>>>>>>> talk
>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>
>>>>>>>>> You are wrong (for the C version of H) because H(P,P) == false
>>>>>>>>> but P(P)
>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>> transitions to
>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free
>>>>>>>>> to deny
>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>
>>>>>>>> If you believe (against the verified facts) that the simulated ⟨Ĥ0⟩
>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>
>>>>>>> I believe what you've told me: that you claim that H(P,P)==false is
>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>
>>>>>> If the input to H(P,P) cannot possibly reach its final state then
>>>>>> this
>>>>>> input is correctly rejected and nothing in the universe can possibly
>>>>>> contradict this.
>>>>>
>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't dispute
>>>>> either (indeed they come from you).
>>>
>>> At least you don't contend these facts.
>>>
>>>>> Your new line in waffle is just an attempt to distract attention
>>>>> from a
>>>>> very simple claim: that the wrong answer is the right one.
>>>>
>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>
>>>> A halt decider must compute the mapping from its inputs (not any damn
>>>> thing else in the universe) to its own final state on the basis of the
>>>> behavior specified by these inputs
>>>
>>> That's not counter intuitive, it's basic.  Everyone knows this, though
>>> it took you a while to get round to it.  A halt decider accepts or
>>> rejects a string based on the behaviour of the computation specified by
>>> that string.  Of course, you never got as far in my exercises as
>>> specifying any TM that decides something on the basis of behaviour, so
>>> you really don't know how it's actually done.  That was, I thought, the
>>> whole point of the exercises -- to see how TMs are specified to decide
>>> properties of computations.
>>>
>>
>> You have to actually pay attention to this, it is the key gap in your
>> reasoning. The following proves that the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
>> embedded_H cannot possibly reach its own final state under any
>> condition what-so-ever.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>
>> When Ĥ is applied to ⟨Ĥ0⟩
>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>> Then these steps would keep repeating:
>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>
>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>> non-halting.
>
> Right, if embedded_H never goes to Qn

It never goes to Qn because there is no Qn, you might as well have said
if embedded_H goes to Disneyland, why is it so difficult for you to get
the details exactly right?

Whether or not embedded_H aborts the simulation of its input this
simulated input never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩,
not even if embedded_H goes to Disneyland, H.qy, H.qn.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<cbk4K.149257$dln7.89696@fx03.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29793&group=comp.theory#29793

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx03.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com> <87pmltcg7x.fsf@bsb.me.uk>
<FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com> <87fsmodh7w.fsf@bsb.me.uk>
<OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com> <87zgkwbh3m.fsf@bsb.me.uk>
<osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com> <87tub4bckx.fsf@bsb.me.uk>
<GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com> <87bkxb9tc9.fsf@bsb.me.uk>
<h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 56
Message-ID: <cbk4K.149257$dln7.89696@fx03.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 14:24:10 -0400
X-Received-Bytes: 4364
 by: Richard Damon - Sat, 9 Apr 2022 18:24 UTC

On 4/9/22 11:20 AM, olcott wrote:
> On 4/9/2022 10:17 AM, Richard Damon wrote:
>> On 4/9/22 10:43 AM, olcott wrote:
>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> I tell one tiny piece of the truth until someone gets it. Then I move
>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>
>>>> Oh pull the other one, it's got bells on!  Actually, you often tell
>>>> massive whoppers and then spend months backpedalling.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>
>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>> Then these steps would keep repeating:
>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>
>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H reaches
>>> its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>
>>>
>>
>> Your right, it doesn't in THAT case,
>
> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still never
> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>

Nope, while embedded_H's simulation never reached thqt state, that
doesn't matter, as it killed its being a source of that fact by that
action. Non-Halting requires that the ACTUAL Machine will never reach a
final state, which can also be shown with an ACTUAL UTM, which BY
DEFINITION doesn't abort its simulation.

The ACTUAL execution of H^ applied to <H^>, and thus the CORRECT
simulation of <H^> <H^> does reach a final state at the exact moment
that embedded_H gets to Qn.

You can't prove non-halting with an aborted simulation that uses unsound
logic. You CAN prove halting by direct execution or simulation with a
REAL UTM.

All you have done is established that embedded_H is a POOP decider,
which you are the only one who cares about it.

Oh, and I guess you have also established that you are totally ignorant
about how Turing Machines and computation work, and that YOU are not a
reliable source of information on this, as you logic in this area is
full of false definitions and lies.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<_ek4K.149258$dln7.21522@fx03.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29794&group=comp.theory#29794

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx03.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<bvh4K.56932$Kdf.46756@fx96.iad>
<-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 130
Message-ID: <_ek4K.149258$dln7.21522@fx03.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 14:28:12 -0400
X-Received-Bytes: 7404
 by: Richard Damon - Sat, 9 Apr 2022 18:28 UTC

On 4/9/22 11:25 AM, olcott wrote:
> On 4/9/2022 10:20 AM, Richard Damon wrote:
>> On 4/9/22 10:41 AM, olcott wrote:
>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its
>>>>>>>>>>>>> input.
>>>>>>>>>>>>
>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>
>>>>>>>>>>> Because I absolutely positively will not tolerate divergence
>>>>>>>>>>> from
>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>
>>>>>>>>>> But you have no choice but to tolerate it.  If someone wants
>>>>>>>>>> to talk
>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>
>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) == false
>>>>>>>>>> but P(P)
>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>> transitions to
>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free
>>>>>>>>>> to deny
>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>
>>>>>>>>> If you believe (against the verified facts) that the simulated
>>>>>>>>> ⟨Ĥ0⟩
>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>
>>>>>>>> I believe what you've told me: that you claim that H(P,P)==false is
>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>
>>>>>>> If the input to H(P,P) cannot possibly reach its final state then
>>>>>>> this
>>>>>>> input is correctly rejected and nothing in the universe can possibly
>>>>>>> contradict this.
>>>>>>
>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't dispute
>>>>>> either (indeed they come from you).
>>>>
>>>> At least you don't contend these facts.
>>>>
>>>>>> Your new line in waffle is just an attempt to distract attention
>>>>>> from a
>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>
>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>
>>>>> A halt decider must compute the mapping from its inputs (not any damn
>>>>> thing else in the universe) to its own final state on the basis of the
>>>>> behavior specified by these inputs
>>>>
>>>> That's not counter intuitive, it's basic.  Everyone knows this, though
>>>> it took you a while to get round to it.  A halt decider accepts or
>>>> rejects a string based on the behaviour of the computation specified by
>>>> that string.  Of course, you never got as far in my exercises as
>>>> specifying any TM that decides something on the basis of behaviour, so
>>>> you really don't know how it's actually done.  That was, I thought, the
>>>> whole point of the exercises -- to see how TMs are specified to decide
>>>> properties of computations.
>>>>
>>>
>>> You have to actually pay attention to this, it is the key gap in your
>>> reasoning. The following proves that the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
>>> embedded_H cannot possibly reach its own final state under any
>>> condition what-so-ever.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>
>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>> Then these steps would keep repeating:
>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>
>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>>> non-halting.
>>
>> Right, if embedded_H never goes to Qn
>
> It never goes to Qn because there is no Qn, you might as well have said
> if embedded_H goes to Disneyland, why is it so difficult for you to get
> the details exactly right?

Then it isn't the required decider!!!!

Read the definition for H.

The machine H is defined starting in Q0 and ending in Qy and Qn, only
when we start having multiple machine in view at once do we add the
namespace qualifies.

>
> Whether or not embedded_H aborts the simulation of its input this
> simulated input never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩,
> not even if embedded_H goes to Disneyland, H.qy, H.qn.
>
>

Nope, The CORRECT simulation (not the simulation done by the decider,
but the CORRECT simulation that maps to the actual Mapping rule) does
reach a final state if H / embedded_H go to the non-halting answer state.

Your problem is you lie about what the right simulation is, so you get
the wrong answer.

Have fun cooking.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29795&group=comp.theory#29795

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 13:31:26 -0500
Date: Sat, 9 Apr 2022 13:31:23 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <cbk4K.149257$dln7.89696@fx03.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 53
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3PAtd0+8xzIlnrZeBRLK6bvKnCXOu1/r6uBYLb2iDpbjA4ORC4PZFl+O+S4CwWAxem/BWeDrPcNPjCE!tGt0rSbozO5Q7PXuGIagjzL9vdbm0Y/8BRwgFhf+02c8JoB+ZANUf6Bf+W6xf9CI1zfYTQr2LnoP
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4341
 by: olcott - Sat, 9 Apr 2022 18:31 UTC

On 4/9/2022 1:24 PM, Richard Damon wrote:
>
> On 4/9/22 11:20 AM, olcott wrote:
>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>> On 4/9/22 10:43 AM, olcott wrote:
>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> I tell one tiny piece of the truth until someone gets it. Then I move
>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>
>>>>> Oh pull the other one, it's got bells on!  Actually, you often tell
>>>>> massive whoppers and then spend months backpedalling.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>
>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>> Then these steps would keep repeating:
>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>
>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>
>>>>
>>>
>>> Your right, it doesn't in THAT case,
>>
>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still never
>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>
>
> Nope, while embedded_H's simulation never reached thqt state, that
> doesn't matter,
Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never reach
its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition
what-so-ever it is by logical necessity that embedded_H would be correct
to transition to its own reject state.

It is like I am saying if we know we have a cat then we know we have an
animal and you are saying that if we know we have a cat then the cat
must be an office building.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<o7-dnU1PXvPLTMz_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29796&group=comp.theory#29796

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 13:32:54 -0500
Date: Sat, 9 Apr 2022 13:32:52 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com> <87o81dgah5.fsf@bsb.me.uk>
<5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com> <87czhtg4z7.fsf@bsb.me.uk>
<jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com> <87pmltenpd.fsf@bsb.me.uk>
<cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com> <877d81ek89.fsf@bsb.me.uk>
<0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com> <87pmltcg7x.fsf@bsb.me.uk>
<FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com> <87fsmodh7w.fsf@bsb.me.uk>
<OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com> <87zgkwbh3m.fsf@bsb.me.uk>
<osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com> <87tub4bckx.fsf@bsb.me.uk>
<GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com> <87bkxb9tc9.fsf@bsb.me.uk>
<h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com> <87ee268n4f.fsf@bsb.me.uk>
<8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<bvh4K.56932$Kdf.46756@fx96.iad>
<-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
<_ek4K.149258$dln7.21522@fx03.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <_ek4K.149258$dln7.21522@fx03.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <o7-dnU1PXvPLTMz_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 146
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ek0LkOKwz//1mG9viGW+L/H+9Og8NqPNC5/hnR8D+ls6u33W8/2N+qieUt9fdoZlLDA8RaOOdxaQh0x!FbbUiI8hNuSVmSLQEWsBGCBZPsVtrxup+9aiWoBl04OGKS1aFyRAbs4C5/SzhEqJLb+ZxhAxeCT+
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8085
 by: olcott - Sat, 9 Apr 2022 18:32 UTC

On 4/9/2022 1:28 PM, Richard Damon wrote:
>
> On 4/9/22 11:25 AM, olcott wrote:
>> On 4/9/2022 10:20 AM, Richard Damon wrote:
>>> On 4/9/22 10:41 AM, olcott wrote:
>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its
>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>
>>>>>>>>>>>> Because I absolutely positively will not tolerate divergence
>>>>>>>>>>>> from
>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>
>>>>>>>>>>> But you have no choice but to tolerate it.  If someone wants
>>>>>>>>>>> to talk
>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>
>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>> false but P(P)
>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>> transitions to
>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free
>>>>>>>>>>> to deny
>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>
>>>>>>>>>> If you believe (against the verified facts) that the simulated
>>>>>>>>>> ⟨Ĥ0⟩
>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>
>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>> H(P,P)==false is
>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>
>>>>>>>> If the input to H(P,P) cannot possibly reach its final state
>>>>>>>> then this
>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>> possibly
>>>>>>>> contradict this.
>>>>>>>
>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't
>>>>>>> dispute
>>>>>>> either (indeed they come from you).
>>>>>
>>>>> At least you don't contend these facts.
>>>>>
>>>>>>> Your new line in waffle is just an attempt to distract attention
>>>>>>> from a
>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>
>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>
>>>>>> A halt decider must compute the mapping from its inputs (not any damn
>>>>>> thing else in the universe) to its own final state on the basis of
>>>>>> the
>>>>>> behavior specified by these inputs
>>>>>
>>>>> That's not counter intuitive, it's basic.  Everyone knows this, though
>>>>> it took you a while to get round to it.  A halt decider accepts or
>>>>> rejects a string based on the behaviour of the computation
>>>>> specified by
>>>>> that string.  Of course, you never got as far in my exercises as
>>>>> specifying any TM that decides something on the basis of behaviour, so
>>>>> you really don't know how it's actually done.  That was, I thought,
>>>>> the
>>>>> whole point of the exercises -- to see how TMs are specified to decide
>>>>> properties of computations.
>>>>>
>>>>
>>>> You have to actually pay attention to this, it is the key gap in
>>>> your reasoning. The following proves that the simulated input ⟨Ĥ0⟩
>>>> ⟨Ĥ1⟩ to embedded_H cannot possibly reach its own final state under
>>>> any condition what-so-ever.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>
>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>> Then these steps would keep repeating:
>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>
>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>>>> non-halting.
>>>
>>> Right, if embedded_H never goes to Qn
>>
>> It never goes to Qn because there is no Qn, you might as well have
>> said if embedded_H goes to Disneyland, why is it so difficult for you
>> to get the details exactly right?
>
> Then it isn't the required decider!!!!
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn
There is no Qn it is called H.qn

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<YCk4K.64531$e%.7672@fx36.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29797&group=comp.theory#29797

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx36.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 86
Message-ID: <YCk4K.64531$e%.7672@fx36.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 14:53:45 -0400
X-Received-Bytes: 5547
 by: Richard Damon - Sat, 9 Apr 2022 18:53 UTC

On 4/9/22 2:31 PM, olcott wrote:
> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>
>> On 4/9/22 11:20 AM, olcott wrote:
>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> I tell one tiny piece of the truth until someone gets it. Then I
>>>>>>> move
>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>
>>>>>> Oh pull the other one, it's got bells on!  Actually, you often tell
>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>> Then these steps would keep repeating:
>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>
>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>
>>>>>
>>>>
>>>> Your right, it doesn't in THAT case,
>>>
>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still never
>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>
>>
>> Nope, while embedded_H's simulation never reached thqt state, that
>> doesn't matter,
> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never reach
> its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition
> what-so-ever it is by logical necessity that embedded_H would be correct
> to transition to its own reject state.

No, that is NOT true. The CORRECT simulation of the input to embedded_H
DOES reach its final state if embedded_H goes to its non-halting answer
state. This has been established. This is the condition that Halting
looks at.

YOUR claimed results, that the simulation by embedded_H never reaches
its final state does not actually prove anything useful.

Either your embedded_H never reaches a final state because it never
actually DECIDES that its input is non-halting, and thus never answers,
and thus fails to be a decider (in this case the input IS non-halting,
but embedded_H doesn't get credit as it never says this).

Or, your embedded_H aborts its simulation (and thus fails to be a UTM)
of an input that DOES reach a final state when simulatated by a REAL
UTM, and thus fails to give the right answer.

>
> It is like I am saying if we know we have a cat then we know we have an
> animal and you are saying that if we know we have a cat then the cat
> must be an office building.
>

Nope, your FIRST is a LIE, the second is a purely hypothetical case that
doesn't actually have a truth value.

You may 'know' you have a cat, just like you 'know' you have the correct
answer, but since you answer is PROVED to be wrong, all we have done is
prove that YOUR knowledge is faulty.

Since the DEFINITION of the right answer for H applied to <M> w is based
on the behavor of M applied to w and NOT some simulation done by H of
<M> w, we know that the TRUTH is based on H^ applied to <H^> which DOES
HALT if H / embedded_H answers non-halting, and it doesn't matter that
embedded_H never saw that final state.

All you have done is prove your own ignorance.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<t2sl07$d7m$1@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29798&group=comp.theory#29798

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!7a25jG6pUKCqa0zKnKnvdg.user.46.165.242.75.POSTED!not-for-mail
From: pyt...@example.invalid (Python)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Date: Sat, 9 Apr 2022 20:58:21 +0200
Organization: Aioe.org NNTP Server
Message-ID: <t2sl07$d7m$1@gioia.aioe.org>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <IKg4K.443016$SeK9.363249@fx97.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="13558"; posting-host="7a25jG6pUKCqa0zKnKnvdg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-GB
 by: Python - Sat, 9 Apr 2022 18:58 UTC

Richard Damon wrote:
....
> My interpretation of what's going on it Peter's head is that he doesn't
> understand to concept of something not existing. He seems to have a
> notion that if you can describe something, there must be some way to
> make it.

This is 100% an accurate description of Olcott's sophistry.

He could "prove" the same way that there exists a prime number
divisible by 2 and 3:

"Let's consider a prime number p so that 2 divides p and 3 divides p"
"It exists a prime number divisible by 2, it's 2 ; also it exists a
prime number divisible by 3, it's 3".
"Conclusion: it exists a prime number divisible by 2 and 3."

Peter won't burn in Hell, because there is no Hell. But he we will
remembered as a kook and a ranting idiot.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29799&group=comp.theory#29799

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 13:58:59 -0500
Date: Sat, 9 Apr 2022 13:58:56 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <YCk4K.64531$e%.7672@fx36.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 70
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-whN81ijCZ1TMLJXqPx5TwbWvNPlxs2hU3r8iyFPSvyIbLHDZUObYKd/WIEvDwwE4399zGJj9m2iiLwL!XSYlOVWCpfW09ZMhyQtUBcepWVqFMPeoiqGsLNFHV6S3SmeSXYkPv+YMAyT1YWw1gg540DHrj1Ej
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5121
 by: olcott - Sat, 9 Apr 2022 18:58 UTC

On 4/9/2022 1:53 PM, Richard Damon wrote:
>
> On 4/9/22 2:31 PM, olcott wrote:
>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>
>>> On 4/9/22 11:20 AM, olcott wrote:
>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> I tell one tiny piece of the truth until someone gets it. Then I
>>>>>>>> move
>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>
>>>>>>> Oh pull the other one, it's got bells on!  Actually, you often tell
>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>> Then these steps would keep repeating:
>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>
>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>
>>>>>>
>>>>>
>>>>> Your right, it doesn't in THAT case,
>>>>
>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still
>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>
>>>
>>> Nope, while embedded_H's simulation never reached thqt state, that
>>> doesn't matter,
>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never reach
>> its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition
>> what-so-ever it is by logical necessity that embedded_H would be
>> correct to transition to its own reject state.
>
> No, that is NOT true. The CORRECT simulation of the input to embedded_H
> DOES reach its final state if embedded_H goes to its non-halting answer
> state. This has been established. This is the condition that Halting
> looks at.

When Ĥ is applied to ⟨Ĥ0⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩

then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
simulated input to immediately stop never ever reaching its own final
state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<t2sl43$d7m$2@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29800&group=comp.theory#29800

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!7a25jG6pUKCqa0zKnKnvdg.user.46.165.242.75.POSTED!not-for-mail
From: pyt...@example.invalid (Python)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Date: Sat, 9 Apr 2022 21:00:25 +0200
Organization: Aioe.org NNTP Server
Message-ID: <t2sl43$d7m$2@gioia.aioe.org>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="13558"; posting-host="7a25jG6pUKCqa0zKnKnvdg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: fr
 by: Python - Sat, 9 Apr 2022 19:00 UTC

Demented LIAR Peter Olcott wrote:
....
> When Ĥ is applied to ⟨Ĥ0⟩
>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>    H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> Then these steps would keep repeating:
>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩

https://imgflip.com/i/69g4jd?herp=1647871628007

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<ntCdnSp0qr5YSsz_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29801&group=comp.theory#29801

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 14:00:21 -0500
Date: Sat, 9 Apr 2022 14:00:19 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87y20iguq6.fsf@bsb.me.uk> <Ad-dnXUjt5cmLND_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <IKg4K.443016$SeK9.363249@fx97.iad>
<t2sl07$d7m$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t2sl07$d7m$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ntCdnSp0qr5YSsz_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 31
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-B3CofCjlgr4qmko8wwWBtLoV/sEGTVeEE7moy6V1x/mrxGofug44vjUnzRyCjxhvAVg1csx3NB05dZB!BkvT002Z3TWOrDjolBnMr7d7qnU/wQ2Wl0YI2iKYRwXLZ6ueSJ+e8FVLyx3pW2Rue1Q9DbDQQPqY
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3204
 by: olcott - Sat, 9 Apr 2022 19:00 UTC

On 4/9/2022 1:58 PM, Python wrote:
> Richard Damon wrote:
> ...
>> My interpretation of what's going on it Peter's head is that he
>> doesn't understand to concept of something not existing. He seems to
>> have a notion that if you can describe something, there must be some
>> way to make it.
>
> This is 100% an accurate description of Olcott's sophistry.
>
> He could "prove" the same way that there exists a prime number
> divisible by 2 and 3:
>
> "Let's consider a prime number p so that 2 divides p and 3 divides p"
> "It exists a prime number divisible by 2, it's 2 ; also it exists a
>  prime number divisible by 3, it's 3".
> "Conclusion: it exists a prime number divisible by 2 and 3."
>
> Peter won't burn in Hell, because there is no Hell. But he we will
> remembered as a kook and a ranting idiot.

And yet you are far too stupid to point out a single error in anything
that I said.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<ITk4K.62597$Kdf.19472@fx96.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29802&group=comp.theory#29802

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx96.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87o81dgah5.fsf@bsb.me.uk> <5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<bvh4K.56932$Kdf.46756@fx96.iad>
<-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
<_ek4K.149258$dln7.21522@fx03.iad>
<o7-dnU1PXvPLTMz_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <o7-dnU1PXvPLTMz_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 197
Message-ID: <ITk4K.62597$Kdf.19472@fx96.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 15:11:37 -0400
X-Received-Bytes: 10150
 by: Richard Damon - Sat, 9 Apr 2022 19:11 UTC

On 4/9/22 2:32 PM, olcott wrote:
> On 4/9/2022 1:28 PM, Richard Damon wrote:
>>
>> On 4/9/22 11:25 AM, olcott wrote:
>>> On 4/9/2022 10:20 AM, Richard Damon wrote:
>>>> On 4/9/22 10:41 AM, olcott wrote:
>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its
>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>
>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone wants
>>>>>>>>>>>> to talk
>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>
>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>> transitions to
>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>> free to deny
>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>
>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>
>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>> H(P,P)==false is
>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>
>>>>>>>>> If the input to H(P,P) cannot possibly reach its final state
>>>>>>>>> then this
>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>> possibly
>>>>>>>>> contradict this.
>>>>>>>>
>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't
>>>>>>>> dispute
>>>>>>>> either (indeed they come from you).
>>>>>>
>>>>>> At least you don't contend these facts.
>>>>>>
>>>>>>>> Your new line in waffle is just an attempt to distract attention
>>>>>>>> from a
>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>
>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>
>>>>>>> A halt decider must compute the mapping from its inputs (not any
>>>>>>> damn
>>>>>>> thing else in the universe) to its own final state on the basis
>>>>>>> of the
>>>>>>> behavior specified by these inputs
>>>>>>
>>>>>> That's not counter intuitive, it's basic.  Everyone knows this,
>>>>>> though
>>>>>> it took you a while to get round to it.  A halt decider accepts or
>>>>>> rejects a string based on the behaviour of the computation
>>>>>> specified by
>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>> specifying any TM that decides something on the basis of
>>>>>> behaviour, so
>>>>>> you really don't know how it's actually done.  That was, I
>>>>>> thought, the
>>>>>> whole point of the exercises -- to see how TMs are specified to
>>>>>> decide
>>>>>> properties of computations.
>>>>>>
>>>>>
>>>>> You have to actually pay attention to this, it is the key gap in
>>>>> your reasoning. The following proves that the simulated input ⟨Ĥ0⟩
>>>>> ⟨Ĥ1⟩ to embedded_H cannot possibly reach its own final state under
>>>>> any condition what-so-ever.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>> Then these steps would keep repeating:
>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>
>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it
>>>>> is non-halting.
>>>>
>>>> Right, if embedded_H never goes to Qn
>>>
>>> It never goes to Qn because there is no Qn, you might as well have
>>> said if embedded_H goes to Disneyland, why is it so difficult for you
>>> to get the details exactly right?
>>
>> Then it isn't the required decider!!!!
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn2.1
> There is no Qn it is called H.qn
>

Maybe you should read your source material.

In H the states are called q0, qy, and qn (the q being normal case, the
following letter a subscript)

I capitalize the q to make it clear from the subscript

Read Definition 12.1

There is no embedded_H, the only machines HE talks about are H, the
actual decider; H', the decider with a loop tagged to the end to the Qy
state and ends up in H'(infinity) (non-halting) and H'qn, and H^ which
adds a duplication stage in front, starting at a NEW q0, going to a H^q0
which is the q0 of H and H', and ends in H^(infinity) (non-halting) or
H^.qn (final)


Click here to read the complete article
Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<uvqdnYHPQeQpRsz_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29803&group=comp.theory#29803

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 14:17:08 -0500
Date: Sat, 9 Apr 2022 14:17:06 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5NCdnXEbkbPQjNP_nZ2dnUU7_8xh4p2d@giganews.com> <87czhtg4z7.fsf@bsb.me.uk>
<jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com> <87pmltenpd.fsf@bsb.me.uk>
<cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com> <877d81ek89.fsf@bsb.me.uk>
<0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com> <87pmltcg7x.fsf@bsb.me.uk>
<FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com> <87fsmodh7w.fsf@bsb.me.uk>
<OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com> <87zgkwbh3m.fsf@bsb.me.uk>
<osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com> <87tub4bckx.fsf@bsb.me.uk>
<GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com> <87bkxb9tc9.fsf@bsb.me.uk>
<h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com> <87ee268n4f.fsf@bsb.me.uk>
<8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<bvh4K.56932$Kdf.46756@fx96.iad>
<-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
<_ek4K.149258$dln7.21522@fx03.iad>
<o7-dnU1PXvPLTMz_nZ2dnUU7_81g4p2d@giganews.com>
<ITk4K.62597$Kdf.19472@fx96.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ITk4K.62597$Kdf.19472@fx96.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <uvqdnYHPQeQpRsz_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 168
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-DTou+/+4vST3oNA2G+mCsYeuKilLiJbXgQwuvIpx3/RVfln4UOXJjdldT/bxKxX6QDiG3DLIkpMHhGq!G4zuXs8+S0p7f7rmeKa1AFncOGbt92uHcKkz720V+jnKZQz/IVPMHRp1zoodMnjYxvkh6/iG2wyS
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8956
 by: olcott - Sat, 9 Apr 2022 19:17 UTC

On 4/9/2022 2:11 PM, Richard Damon wrote:
>
> On 4/9/22 2:32 PM, olcott wrote:
>> On 4/9/2022 1:28 PM, Richard Damon wrote:
>>>
>>> On 4/9/22 11:25 AM, olcott wrote:
>>>> On 4/9/2022 10:20 AM, Richard Damon wrote:
>>>>> On 4/9/22 10:41 AM, olcott wrote:
>>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject
>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone
>>>>>>>>>>>>> wants to talk
>>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>>> transitions to
>>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>>> free to deny
>>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>>
>>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>>
>>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>>> H(P,P)==false is
>>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>>
>>>>>>>>>> If the input to H(P,P) cannot possibly reach its final state
>>>>>>>>>> then this
>>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>>> possibly
>>>>>>>>>> contradict this.
>>>>>>>>>
>>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't
>>>>>>>>> dispute
>>>>>>>>> either (indeed they come from you).
>>>>>>>
>>>>>>> At least you don't contend these facts.
>>>>>>>
>>>>>>>>> Your new line in waffle is just an attempt to distract
>>>>>>>>> attention from a
>>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>>
>>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>>
>>>>>>>> A halt decider must compute the mapping from its inputs (not any
>>>>>>>> damn
>>>>>>>> thing else in the universe) to its own final state on the basis
>>>>>>>> of the
>>>>>>>> behavior specified by these inputs
>>>>>>>
>>>>>>> That's not counter intuitive, it's basic.  Everyone knows this,
>>>>>>> though
>>>>>>> it took you a while to get round to it.  A halt decider accepts or
>>>>>>> rejects a string based on the behaviour of the computation
>>>>>>> specified by
>>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>>> specifying any TM that decides something on the basis of
>>>>>>> behaviour, so
>>>>>>> you really don't know how it's actually done.  That was, I
>>>>>>> thought, the
>>>>>>> whole point of the exercises -- to see how TMs are specified to
>>>>>>> decide
>>>>>>> properties of computations.
>>>>>>>
>>>>>>
>>>>>> You have to actually pay attention to this, it is the key gap in
>>>>>> your reasoning. The following proves that the simulated input ⟨Ĥ0⟩
>>>>>> ⟨Ĥ1⟩ to embedded_H cannot possibly reach its own final state under
>>>>>> any condition what-so-ever.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>> Then these steps would keep repeating:
>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>
>>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H
>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know
>>>>>> that it is non-halting.
>>>>>
>>>>> Right, if embedded_H never goes to Qn
>>>>
>>>> It never goes to Qn because there is no Qn, you might as well have
>>>> said if embedded_H goes to Disneyland, why is it so difficult for
>>>> you to get the details exactly right?
>>>
>>> Then it isn't the required decider!!!!
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn2.1
>> There is no Qn it is called H.qn
>>
>
> Maybe you should read your source material.
>
> In H the states are called q0, qy, and qn (the q being normal case, the
> following letter a subscript)
>
> I capitalize the q to make it clear from the subscript
>
> Read Definition 12.1
>
> There is no embedded_H, the only machines HE talks about are H, the


Click here to read the complete article
Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<V1l4K.810561$aT3.662905@fx09.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29804&group=comp.theory#29804

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 108
Message-ID: <V1l4K.810561$aT3.662905@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 15:22:30 -0400
X-Received-Bytes: 6713
 by: Richard Damon - Sat, 9 Apr 2022 19:22 UTC

On 4/9/22 2:58 PM, olcott wrote:
> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>
>> On 4/9/22 2:31 PM, olcott wrote:
>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>
>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> I tell one tiny piece of the truth until someone gets it. Then
>>>>>>>>> I move
>>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>>
>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you often tell
>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>> Then these steps would keep repeating:
>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>
>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Your right, it doesn't in THAT case,
>>>>>
>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still
>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>
>>>>
>>>> Nope, while embedded_H's simulation never reached thqt state, that
>>>> doesn't matter,
>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never reach
>>> its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition
>>> what-so-ever it is by logical necessity that embedded_H would be
>>> correct to transition to its own reject state.
>>
>> No, that is NOT true. The CORRECT simulation of the input to
>> embedded_H DOES reach its final state if embedded_H goes to its
>> non-halting answer state. This has been established. This is the
>> condition that Halting looks at.
>
> When Ĥ is applied to ⟨Ĥ0⟩
>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>    H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> Then these steps would keep repeating:
>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>
> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
> simulated input to immediately stop never ever reaching its own final
> state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>
>

Nope, and simulator that aborts its simulation my terminate its own
action, but does NOT change the behavior of the input, which is based on
the actual behavior of the machine represented by the input, which the
simulator has no power over.

From the definiton H applied <M> w -> Qy if M applied to w will Halt
and -> Qn if M applied to w never halts shows that the DEFINITON of
behavior that we need to look at is the actual machine, so H^ applied to
<H^> (which the embedded_H inside of that H^ can not 'abort') and thus
that actual trace that you are describing is:

H^ appled to <H^0>
H^ copies its input <H^0> to <H^1>
H^ uses H to decide by simulation on <H^0><H^1>
H then simulates H^0 copying its input <H^1> to <H^2>
H then simulates H^0 using H0 to decide by simulation on <H^1> <H^2>
(maybe a few more loops in here)
H then aborts is simulation deciding that this loop will go on forever
H then goes to Qn which is also H^Qn
H^Qn is a final state, so H^ Halts.

Thus H^ applied to <H^> is a Halting Computation and thus <H^> <H^>
represents a Halting Computation.

Your logic erroneously presumes that the fact that you can show that NO
variation of H can ever reach a final state somehow defines the input to
be non-halting.

The problem is we don't care about what 'any variation' of H does, we
care about what THIS version of H does. If it aborts, then from above we
show that by the ACTUAL DEFINITION of Halting, the input is Halting.

If H doesn't abort its simulation, they yes, H^ becomes non-halting. but
that version of H fails to be a decider so it can't get credit for the
answer it didn't give.

Your 'criteria' is actually an invalid one, because it doesn't actually
look at the behavior of ANY given Turing Machine, but tries to reason
about a class of machines, and uses the wrong defintion of Halting.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ ridiculously stupid ]

<7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29805&group=comp.theory#29805

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 14:30:51 -0500
Date: Sat, 9 Apr 2022 14:30:48 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
<V1l4K.810561$aT3.662905@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <V1l4K.810561$aT3.662905@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 80
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PE9ZNbLd3SxZpVSeT17E/upJxl7v07RTNhnvSOJ2Gjq/8dOOR2XJEuoNJJP8Ztl4dO/PGOoWYJDcDMo!CQaMgpKOy0xlgoeNixF85v2qLA87ZkIrZkMeQPxlFYRgISYB9/YldWF5KQmjJJD2756v9h0dYAOY
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5599
 by: olcott - Sat, 9 Apr 2022 19:30 UTC

On 4/9/2022 2:22 PM, Richard Damon wrote:
> On 4/9/22 2:58 PM, olcott wrote:
>> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>>
>>> On 4/9/22 2:31 PM, olcott wrote:
>>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>>
>>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> I tell one tiny piece of the truth until someone gets it. Then
>>>>>>>>>> I move
>>>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>>>
>>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you often
>>>>>>>>> tell
>>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>> Then these steps would keep repeating:
>>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>
>>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Your right, it doesn't in THAT case,
>>>>>>
>>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still
>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>
>>>>>
>>>>> Nope, while embedded_H's simulation never reached thqt state, that
>>>>> doesn't matter,
>>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never
>>>> reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition
>>>> what-so-ever it is by logical necessity that embedded_H would be
>>>> correct to transition to its own reject state.
>>>
>>> No, that is NOT true. The CORRECT simulation of the input to
>>> embedded_H DOES reach its final state if embedded_H goes to its
>>> non-halting answer state. This has been established. This is the
>>> condition that Halting looks at.
>>
>> When Ĥ is applied to ⟨Ĥ0⟩
>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>> Then these steps would keep repeating:
>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>
>> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
>> simulated input to immediately stop never ever reaching its own final
>> state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>
>>
>
> Nope, and simulator that aborts its simulation my terminate its own
> action, but does NOT change the behavior of the input,

It is ridiculously stupid to believe that an aborted simulation keeps
running after it have been aborted.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]

<Ngl4K.31250$r_.24642@fx41.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29806&group=comp.theory#29806

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx41.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhtg4z7.fsf@bsb.me.uk> <jfmdnYpE_-Sou9P_nZ2dnUU7_8zNnZ2d@giganews.com>
<87pmltenpd.fsf@bsb.me.uk> <cfudncxuyvpiqtP_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d81ek89.fsf@bsb.me.uk> <0rydndjRmYSt2NP_nZ2dnUU7_81g4p2d@giganews.com>
<87pmltcg7x.fsf@bsb.me.uk> <FOidnTmeDpgxa9P_nZ2dnUU7_8xh4p2d@giganews.com>
<87fsmodh7w.fsf@bsb.me.uk> <OrOdnfRPxcJak9L_nZ2dnUU7_8xh4p2d@giganews.com>
<87zgkwbh3m.fsf@bsb.me.uk> <osadnV2OUrMF6tL_nZ2dnUU7_83NnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<bvh4K.56932$Kdf.46756@fx96.iad>
<-LadnZqQb_foOMz_nZ2dnUU7_8zNnZ2d@giganews.com>
<_ek4K.149258$dln7.21522@fx03.iad>
<o7-dnU1PXvPLTMz_nZ2dnUU7_81g4p2d@giganews.com>
<ITk4K.62597$Kdf.19472@fx96.iad>
<uvqdnYHPQeQpRsz_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <uvqdnYHPQeQpRsz_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 198
Message-ID: <Ngl4K.31250$r_.24642@fx41.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 15:38:23 -0400
X-Received-Bytes: 10042
 by: Richard Damon - Sat, 9 Apr 2022 19:38 UTC

On 4/9/22 3:17 PM, olcott wrote:
> On 4/9/2022 2:11 PM, Richard Damon wrote:
>>
>> On 4/9/22 2:32 PM, olcott wrote:
>>> On 4/9/2022 1:28 PM, Richard Damon wrote:
>>>>
>>>> On 4/9/22 11:25 AM, olcott wrote:
>>>>> On 4/9/2022 10:20 AM, Richard Damon wrote:
>>>>>> On 4/9/22 10:41 AM, olcott wrote:
>>>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject
>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone
>>>>>>>>>>>>>> wants to talk
>>>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>>>> transitions to
>>>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>>>> free to deny
>>>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>>>> H(P,P)==false is
>>>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>>>
>>>>>>>>>>> If the input to H(P,P) cannot possibly reach its final state
>>>>>>>>>>> then this
>>>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>>>> possibly
>>>>>>>>>>> contradict this.
>>>>>>>>>>
>>>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't
>>>>>>>>>> dispute
>>>>>>>>>> either (indeed they come from you).
>>>>>>>>
>>>>>>>> At least you don't contend these facts.
>>>>>>>>
>>>>>>>>>> Your new line in waffle is just an attempt to distract
>>>>>>>>>> attention from a
>>>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>>>
>>>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>>>
>>>>>>>>> A halt decider must compute the mapping from its inputs (not
>>>>>>>>> any damn
>>>>>>>>> thing else in the universe) to its own final state on the basis
>>>>>>>>> of the
>>>>>>>>> behavior specified by these inputs
>>>>>>>>
>>>>>>>> That's not counter intuitive, it's basic.  Everyone knows this,
>>>>>>>> though
>>>>>>>> it took you a while to get round to it.  A halt decider accepts or
>>>>>>>> rejects a string based on the behaviour of the computation
>>>>>>>> specified by
>>>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>>>> specifying any TM that decides something on the basis of
>>>>>>>> behaviour, so
>>>>>>>> you really don't know how it's actually done.  That was, I
>>>>>>>> thought, the
>>>>>>>> whole point of the exercises -- to see how TMs are specified to
>>>>>>>> decide
>>>>>>>> properties of computations.
>>>>>>>>
>>>>>>>
>>>>>>> You have to actually pay attention to this, it is the key gap in
>>>>>>> your reasoning. The following proves that the simulated input
>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H cannot possibly reach its own final state
>>>>>>> under any condition what-so-ever.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>> Then these steps would keep repeating:
>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>
>>>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H
>>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know
>>>>>>> that it is non-halting.
>>>>>>
>>>>>> Right, if embedded_H never goes to Qn
>>>>>
>>>>> It never goes to Qn because there is no Qn, you might as well have
>>>>> said if embedded_H goes to Disneyland, why is it so difficult for
>>>>> you to get the details exactly right?
>>>>
>>>> Then it isn't the required decider!!!!
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn
>>> There is no Qn it is called H.qn2.1
>>> There is no Qn it is called H.qn
>>>
>>
>> Maybe you should read your source material.
>>
>> In H the states are called q0, qy, and qn (the q being normal case,
>> the following letter a subscript)
>>
>> I capitalize the q to make it clear from the subscript
>>
>> Read Definition 12.1
>>
>> There is no embedded_H, the only machines HE talks about are H, the
>
> He talks about the copy of H that is embedded in Ĥ, numbskull, I
> abbreviate this to: embedded_H.
>


Click here to read the complete article
Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ ridiculously stupid ]

<Gkl4K.564829$7F2.521914@fx12.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29807&group=comp.theory#29807

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87tub4bckx.fsf@bsb.me.uk> <GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
<V1l4K.810561$aT3.662905@fx09.iad>
<7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 98
Message-ID: <Gkl4K.564829$7F2.521914@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 15:42:31 -0400
X-Received-Bytes: 6094
 by: Richard Damon - Sat, 9 Apr 2022 19:42 UTC

On 4/9/22 3:30 PM, olcott wrote:
> On 4/9/2022 2:22 PM, Richard Damon wrote:
>> On 4/9/22 2:58 PM, olcott wrote:
>>> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>>>
>>>> On 4/9/22 2:31 PM, olcott wrote:
>>>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> I tell one tiny piece of the truth until someone gets it.
>>>>>>>>>>> Then I move
>>>>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>>>>
>>>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you often
>>>>>>>>>> tell
>>>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>
>>>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Your right, it doesn't in THAT case,
>>>>>>>
>>>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still
>>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>
>>>>>>
>>>>>> Nope, while embedded_H's simulation never reached thqt state, that
>>>>>> doesn't matter,
>>>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never
>>>>> reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition
>>>>> what-so-ever it is by logical necessity that embedded_H would be
>>>>> correct to transition to its own reject state.
>>>>
>>>> No, that is NOT true. The CORRECT simulation of the input to
>>>> embedded_H DOES reach its final state if embedded_H goes to its
>>>> non-halting answer state. This has been established. This is the
>>>> condition that Halting looks at.
>>>
>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>> Then these steps would keep repeating:
>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>
>>> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
>>> simulated input to immediately stop never ever reaching its own final
>>> state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>
>>>
>>
>> Nope, and simulator that aborts its simulation my terminate its own
>> action, but does NOT change the behavior of the input,
>
> It is ridiculously stupid to believe that an aborted simulation keeps
> running after it have been aborted.
>

You just aren't understanding the words.

I am not saying the ABORTED simulation continues, but the CORRECT
simulation and the actual machine behavior do, by definition.

You are just so stuck at looking at the wrong thing you can't even
understand what is happening.

As I have pointed out, just because you get off the highway at exit 5
doesn't mean the highway doesn't continue past that, and eventually
reaches its terminous.

The fact that H (or whatever you want to call the copy of it) aborts its
simulation of the input, doesn't mean that there isn't more behavior to
that input.

We are looking at the behavior of the machine represented by the input
to H, not the behavior of H simulating the input.

Work with the wrong defintions, and you get the wrong answers.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ ridiculously stupid ]

<OrWdnfFdxKTdfsz_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29808&group=comp.theory#29808

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 14:49:20 -0500
Date: Sat, 9 Apr 2022 14:49:17 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<GfWdneVhSvpN183_nZ2dnUU7_83NnZ2d@giganews.com> <87bkxb9tc9.fsf@bsb.me.uk>
<h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
<V1l4K.810561$aT3.662905@fx09.iad>
<7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>
<Gkl4K.564829$7F2.521914@fx12.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <Gkl4K.564829$7F2.521914@fx12.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OrWdnfFdxKTdfsz_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 98
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tVldUmeFtNdrVVu19NLqWQYFun0NZXrjnEciV5lTUFnZl8CsuLNXr6pNbd5FMF90AEFN46EXXGdVTHW!lI8rfcY4fZBJxFFT503tS1NIXL7F4Z0XVl3joU8nnfdl+dglAbandsmYH2wrOyYEfpDs29ZViSp0
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6408
 by: olcott - Sat, 9 Apr 2022 19:49 UTC

On 4/9/2022 2:42 PM, Richard Damon wrote:
> On 4/9/22 3:30 PM, olcott wrote:
>> On 4/9/2022 2:22 PM, Richard Damon wrote:
>>> On 4/9/22 2:58 PM, olcott wrote:
>>>> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>>>>
>>>>> On 4/9/22 2:31 PM, olcott wrote:
>>>>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> I tell one tiny piece of the truth until someone gets it.
>>>>>>>>>>>> Then I move
>>>>>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>>>>>
>>>>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you
>>>>>>>>>>> often tell
>>>>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>
>>>>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>>>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Your right, it doesn't in THAT case,
>>>>>>>>
>>>>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still
>>>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, while embedded_H's simulation never reached thqt state,
>>>>>>> that doesn't matter,
>>>>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never
>>>>>> reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any
>>>>>> condition what-so-ever it is by logical necessity that embedded_H
>>>>>> would be correct to transition to its own reject state.
>>>>>
>>>>> No, that is NOT true. The CORRECT simulation of the input to
>>>>> embedded_H DOES reach its final state if embedded_H goes to its
>>>>> non-halting answer state. This has been established. This is the
>>>>> condition that Halting looks at.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>> Then these steps would keep repeating:
>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>
>>>> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
>>>> simulated input to immediately stop never ever reaching its own
>>>> final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>
>>>>
>>>
>>> Nope, and simulator that aborts its simulation my terminate its own
>>> action, but does NOT change the behavior of the input,
>>
>> It is ridiculously stupid to believe that an aborted simulation keeps
>> running after it have been aborted.
>>
>
> You just aren't understanding the words.
>
> I am not saying the ABORTED simulation continues, but the CORRECT
> simulation and the actual machine behavior do, by definition.

Under no circumstances what-so-ever does the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩
to embedded_H meet this Linz criteria of a halting computation:

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

Therefore people that do not have severe brain damage will understand
that embedded_H would be correct to reject this input as non-halting.

--
Copyright 2022 Pete Olcott

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

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ ridiculously stupid ]

<DNl4K.327353$Lbb6.62351@fx45.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29809&group=comp.theory#29809

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
<V1l4K.810561$aT3.662905@fx09.iad>
<7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>
<Gkl4K.564829$7F2.521914@fx12.iad>
<OrWdnfFdxKTdfsz_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <OrWdnfFdxKTdfsz_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 134
Message-ID: <DNl4K.327353$Lbb6.62351@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 9 Apr 2022 16:13:24 -0400
X-Received-Bytes: 7581
 by: Richard Damon - Sat, 9 Apr 2022 20:13 UTC

On 4/9/22 3:49 PM, olcott wrote:
> On 4/9/2022 2:42 PM, Richard Damon wrote:
>> On 4/9/22 3:30 PM, olcott wrote:
>>> On 4/9/2022 2:22 PM, Richard Damon wrote:
>>>> On 4/9/22 2:58 PM, olcott wrote:
>>>>> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 4/9/22 2:31 PM, olcott wrote:
>>>>>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> I tell one tiny piece of the truth until someone gets it.
>>>>>>>>>>>>> Then I move
>>>>>>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>>>>>>
>>>>>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you
>>>>>>>>>>>> often tell
>>>>>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>
>>>>>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H
>>>>>>>>>>> reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Your right, it doesn't in THAT case,
>>>>>>>>>
>>>>>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it still
>>>>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, while embedded_H's simulation never reached thqt state,
>>>>>>>> that doesn't matter,
>>>>>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never
>>>>>>> reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any
>>>>>>> condition what-so-ever it is by logical necessity that embedded_H
>>>>>>> would be correct to transition to its own reject state.
>>>>>>
>>>>>> No, that is NOT true. The CORRECT simulation of the input to
>>>>>> embedded_H DOES reach its final state if embedded_H goes to its
>>>>>> non-halting answer state. This has been established. This is the
>>>>>> condition that Halting looks at.
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>> Then these steps would keep repeating:
>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>
>>>>> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
>>>>> simulated input to immediately stop never ever reaching its own
>>>>> final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>
>>>>>
>>>>
>>>> Nope, and simulator that aborts its simulation my terminate its own
>>>> action, but does NOT change the behavior of the input,
>>>
>>> It is ridiculously stupid to believe that an aborted simulation keeps
>>> running after it have been aborted.
>>>
>>
>> You just aren't understanding the words.
>>
>> I am not saying the ABORTED simulation continues, but the CORRECT
>> simulation and the actual machine behavior do, by definition.
>
> Under no circumstances what-so-ever does the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩
> to embedded_H meet this Linz criteria of a halting computation:

That is just a LIE based on NOT looking at an ACTUAL CORRECT simulation
of the input.

The ACTUAL behavior of the input to H / embedded_H, the input string
<H^> <H^> has been PROVEN to Halt if H / embedded_H reject that input
and go to Qn.

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

Which means the ACTUAL TURING MACHINE, not a simulation.

For this definition, the ONLY thing that the input <H^> <H^> looks at is
the actual computation H^ applied to <H^> PERIOD, DEFINITION.

Anythibng else can only be used by first showing actual equivalence to
that DEFINITION.

The 'simulation' of the input by H / embedded_H FAILS to meet that
equivalence test if it aborts its simulation, so is irrelevent.

>
> Therefore people that do not have severe brain damage will understand
> that embedded_H would be correct to reject this input as non-halting.
>

Nope. That you don't understand it just shows that you are the strawman
and don't have a brain.

Remember the DEFINITION of the correct answer is:

H applied to <M> w goes to Qy if M applied to w Halts, and to Qn if M
applied to w never halts.

Thus the correct answer to H applied to <H^> <H^> is to go to Qy if H^
applied to <H^> Halts (and to Qn if it never halts), and H^ applied to
<H^> does halt if H rejects its input by going to Qn.

Thus it is IMPOSSIBLE for H (or embedded_H since it works under the
exact same definition) to be correct to reject and go to Qn, since if it
does. BY DEFINITION the input represent a Halting Computation and it
needed to accept that input.

FAIL

You are just proving you are an idiot.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ ridiculously stupid ]

<zM2dnSfUtf-vd8z_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=29810&group=comp.theory#29810

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Apr 2022 15:18:58 -0500
Date: Sat, 9 Apr 2022 15:18:56 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.8.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
ridiculously stupid ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<5ba98982-64c6-4169-93d3-170bdff4033fn@googlegroups.com>
<v8ednWienfL2Ic3_nZ2dnUU7_83NnZ2d@giganews.com>
<2B34K.792470$aT3.128169@fx09.iad>
<_YidneB_LP4CW83_nZ2dnUU7_81g4p2d@giganews.com>
<GF44K.31231$r_.15461@fx41.iad>
<A7ednRZ2DIJGR83_nZ2dnUU7_83NnZ2d@giganews.com>
<Ml54K.792474$aT3.709472@fx09.iad>
<dPKdnYwT-JcceM3_nZ2dnUU7_83NnZ2d@giganews.com> <878rse8mpz.fsf@bsb.me.uk>
<8qOdnanOrqcPBsz_nZ2dnUU7_81g4p2d@giganews.com>
<esh4K.210689$OT%7.200542@fx07.iad>
<bOudnetnF9vGOcz_nZ2dnUU7_81g4p2d@giganews.com>
<cbk4K.149257$dln7.89696@fx03.iad>
<o7-dnVJPXvNjTcz_nZ2dnUU7_83NnZ2d@giganews.com>
<YCk4K.64531$e%.7672@fx36.iad>
<ntCdnSt0qr7uSsz_nZ2dnUU7_83NnZ2d@giganews.com>
<V1l4K.810561$aT3.662905@fx09.iad>
<7JGdnZEzGrp2Q8z_nZ2dnUU7_8zNnZ2d@giganews.com>
<Gkl4K.564829$7F2.521914@fx12.iad>
<OrWdnfFdxKTdfsz_nZ2dnUU7_8zNnZ2d@giganews.com>
<DNl4K.327353$Lbb6.62351@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <DNl4K.327353$Lbb6.62351@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <zM2dnSfUtf-vd8z_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 139
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wr8xtzP8mzfSiB7fpg5VeYUqcOhtobx6BbhUk9kRpCfirS8DpyOAVbu3rDB6VjJXYUkp28O/miL1lql!GivOrbAnNf0hS3tjhpOUnb+qEShtESxjIt+grG306UvPKuRWElOG85gkP1eeP+JcXpk5ovTzijBd
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8042
 by: olcott - Sat, 9 Apr 2022 20:18 UTC

On 4/9/2022 3:13 PM, Richard Damon wrote:
> On 4/9/22 3:49 PM, olcott wrote:
>> On 4/9/2022 2:42 PM, Richard Damon wrote:
>>> On 4/9/22 3:30 PM, olcott wrote:
>>>> On 4/9/2022 2:22 PM, Richard Damon wrote:
>>>>> On 4/9/22 2:58 PM, olcott wrote:
>>>>>> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 4/9/22 2:31 PM, olcott wrote:
>>>>>>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>>>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> I tell one tiny piece of the truth until someone gets it.
>>>>>>>>>>>>>> Then I move
>>>>>>>>>>>>>> on to the next tiny piece of the truth until someone gets it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you
>>>>>>>>>>>>> often tell
>>>>>>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩
>>>>>>>>>>>> ⟨Ĥ2⟩
>>>>>>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩
>>>>>>>>>>>> ⟨Ĥ3⟩
>>>>>>>>>>>>
>>>>>>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
>>>>>>>>>>>> embedded_H reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Your right, it doesn't in THAT case,
>>>>>>>>>>
>>>>>>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it
>>>>>>>>>> still never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, while embedded_H's simulation never reached thqt state,
>>>>>>>>> that doesn't matter,
>>>>>>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would never
>>>>>>>> reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any
>>>>>>>> condition what-so-ever it is by logical necessity that
>>>>>>>> embedded_H would be correct to transition to its own reject state.
>>>>>>>
>>>>>>> No, that is NOT true. The CORRECT simulation of the input to
>>>>>>> embedded_H DOES reach its final state if embedded_H goes to its
>>>>>>> non-halting answer state. This has been established. This is the
>>>>>>> condition that Halting looks at.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>> Then these steps would keep repeating:
>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>
>>>>>> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
>>>>>> simulated input to immediately stop never ever reaching its own
>>>>>> final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, and simulator that aborts its simulation my terminate its own
>>>>> action, but does NOT change the behavior of the input,
>>>>
>>>> It is ridiculously stupid to believe that an aborted simulation
>>>> keeps running after it have been aborted.
>>>>
>>>
>>> You just aren't understanding the words.
>>>
>>> I am not saying the ABORTED simulation continues, but the CORRECT
>>> simulation and the actual machine behavior do, by definition.
>>
>> Under no circumstances what-so-ever does the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩
>> to embedded_H meet this Linz criteria of a halting computation:
>
> That is just a LIE based on NOT looking at an ACTUAL CORRECT simulation
> of the input.
>
> The ACTUAL behavior of the input to H / embedded_H, the input string
> <H^> <H^> has been PROVEN to Halt if H / embedded_H reject that input
> and go to Qn.
>
>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
> Which means the ACTUAL TURING MACHINE, not a simulation.
>
> For this definition, the ONLY thing that the input <H^> <H^> looks at is
> the actual computation H^ applied to <H^> PERIOD, DEFINITION.
>
> Anythibng else can only be used by first showing actual equivalence to
> that DEFINITION.
>
> The 'simulation' of the input by H / embedded_H FAILS to meet that
> equivalence test if it aborts its simulation, so is irrelevent.
>
>>
>> Therefore people that do not have severe brain damage will understand
>> that embedded_H would be correct to reject this input as non-halting.
>>
>
> Nope. That you don't understand it just shows that you are the strawman
> and don't have a brain.
>
> Remember the DEFINITION of the correct answer is:

The computation of the mapping of the inputs to an accept or reject
state based on the actual behavior of these actual inputs.

The actual behavior of the actual input never meets the Linz definition
of halting under any condition what-so-ever thus is correctly judged as
a non-halting input.

You reasoning goes like this: We know that a dog is an animal and we
know that a cat is an animal therefore a dog is a cat.

--
Copyright 2022 Pete Olcott

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

Pages:12345678910111213141516171819202122232425262728293031323334353637383940
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor