Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Marriage is low down, but you spend the rest of your life paying for it." -- Baskins


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

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 ] H(P,P)

<YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 14 Apr 2022 17:16:14 -0500
Date: Thu, 14 Apr 2022 17:16:13 -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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87a6cr2j8p.fsf@bsb.me.uk> <7_OdnfY0NISyScn_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <8735ifs7vo.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 120
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WFgQ309zBOROsVJTUG2MZmV4ny6mNCU8Eo7tYePxvOLrgpP14iVg0NIuttO4J2fvVfdO3PLyQrWvKWW!HjUUaAo2kCiqjV3GNjbxe0b/4qBVFUsWY/IPTf41zRyq1PSVtujmemW5UXcsHko0e1s4U761XwQj
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: 7149
 by: olcott - Thu, 14 Apr 2022 22:16 UTC

On 4/14/2022 3:54 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/14/2022 11:40 AM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>
>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said that
>>>>>>>>> P(P) halts. Oh, there is a third (c) you are using poetic license, and
>>>>>>>>> simulating the input means something silly. It's literal nonsense to
>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>
>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>>>>
>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>>>>> That's not rhetoric. You've been too clear about this attempt. You
>>>>>>> need to try a new ruse.
>>>>>>
>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>
>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>> pointers. They are neither halting nor non-halting -- they are just
>>>>> pointers.
>>>>>
>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>> non-halting" means,
>>>>
>>>> Sure when I make to to explain ever details many hundreds of times
>>>> damned liars will say that I never mentioned any of this.
>>> Just use the right terms. H(P,P) has not input. The call has
>>> arguments. They are just pointers. Pointers are not halting nor are
>>> they non halting. Given that this mantra is the core of what you are
>>> now claiming, I would have thought you would want to avoid it being
>>> patentent nonsense.
>>>
>>>> The input to H is the only way that finite strings can be passed to a
>>>> "C" function and points to the finite string of the machine code of P.
>>> H has no input. Do you mean the two pointer arguments?
>>>
>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>> input (P,P) and finds that it would never reach its own final state in
>>>> an unlimited number of simulated steps.
>>>
>>> (P,P) is too vague. What needs to be simulated is the first pointer
>>> being called as a function with the second as it's argument. I.e. the
>>> call P(P) is what should be simulated.
>>
>> That the correctly simulated input to H(P,P) cannot possibly reach its
>> own final state proves that this input is not-halting.
>>
>> Adding all of the tedious details that you suggest does not change
>> this fact.
>
> If you add all the corrections, sorry, "tedious details", it contradicts
> what you've said in the past. With the errors left in place, the naive
> reader won't knowing exactly what's being said -- and I think that's
> deliberate.
>
> For example, why talk about simulation at all since simulations of
> computations halt or don't halt if and only if the computations do
> themselves? Well, it adds yet another puff of smoke to the mirrors
> you've got in there already like what that "its" refers to (since
> nothing here has a final state), or what non-halting pointers are.
>
> "The input to H(P,P)" should mean the two pointers, P and P. Simulating
> them should mean simulating the call P(P) and the simulation "not
> reaching its own final state" should mean that the simulation of P(P)
> does not halt. And that happens if, and only if, the call P(P) itself
> does not halt.
>
> I honestly have no idea if that is what you mean, but if it is, it's
> wrong because P(P) halts. You are probably just trying to cover that
> up.
>

That a non input halts, converts the world to Fascism or opens a very
popular brothel is totally unrelated to the easily confirmed fact that
the input to H(P,P)* does not halt.

*standard functional notation

_P()
[00000956](01) 55 push ebp
[00000957](02) 8bec mov ebp,esp
[00000959](03) 8b4508 mov eax,[ebp+08]
[0000095c](01) 50 push eax // push P
[0000095d](03) 8b4d08 mov ecx,[ebp+08]
[00000960](01) 51 push ecx // push P
[00000961](05) e8c0feffff call 00000826 // call H(P,P)
The above keeps repeating until aborted

[00000966](03) 83c408 add esp,+08
[00000969](02) 85c0 test eax,eax
[0000096b](02) 7402 jz 0000096f
[0000096d](02) ebfe jmp 0000096d
[0000096f](01) 5d pop ebp
[00000970](01) c3 ret // final state.
Size in bytes:(0027) [00000970]

--
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 ] H(P,P)

<Sn16K.213384$OT%7.192595@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87v8vg4nw5.fsf@bsb.me.uk> <9tydnQaOy_a2z87_nZ2dnUU7_81g4p2d@giganews.com>
<87k0bw4hgi.fsf@bsb.me.uk> <zJqdnWuS9-Zh8s7_nZ2dnUU7_81g4p2d@giganews.com>
<87r1632n6i.fsf@bsb.me.uk> <LeidnWJCD90dXcn_nZ2dnUU7_8xh4p2d@giganews.com>
<87a6cr2j8p.fsf@bsb.me.uk> <7_OdnfY0NISyScn_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<b866e22d-423b-4c52-88fb-60b924930a1an@googlegroups.com>
<Ge2dnbfhksXvrMX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Ge2dnbfhksXvrMX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 90
Message-ID: <Sn16K.213384$OT%7.192595@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: Thu, 14 Apr 2022 18:38:43 -0400
X-Received-Bytes: 5596
 by: Richard Damon - Thu, 14 Apr 2022 22:38 UTC

On 4/14/22 10:36 AM, olcott wrote:
> On 4/14/2022 3:56 AM, Malcolm McLean wrote:
>> On Thursday, 14 April 2022 at 01:37:11 UTC+1, olcott wrote:
>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>> olcott <No...@NoWhere.com> writes:
>>>>
>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>> olcott <No...@NoWhere.com> writes:
>>>>
>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>
>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said
>>>>>> that
>>>>>> P(P) halts. Oh, there is a third (c) you are using poetic license,
>>>>>> and
>>>>>> simulating the input means something silly. It's literal nonsense to
>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>
>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>
>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>> That's not rhetoric. You've been too clear about this attempt. You
>>>> need to try a new ruse.
>>>>
>>> Because the input to H(P,P) is non-halting then nothing in the universe
>>> can possibly contradict the fact that it is non-halting.
>>> The simulated input to H(P,P) cannot possibly reach its own final state
>>> it keeps repeating [00000956] to [00000961] until aborted.
>>>
>>> _P()
>>> [00000956](01) 55 push ebp
>>> [00000957](02) 8bec mov ebp,esp
>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>> [0000095c](01) 50 push eax // push P
>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000960](01) 51 push ecx // push P
>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>> The above keeps repeating until aborted
>>>
>>>
>>> [00000966](03) 83c408 add esp,+08
>>> [00000969](02) 85c0 test eax,eax
>>> [0000096b](02) 7402 jz 0000096f
>>> [0000096d](02) ebfe jmp 0000096d
>>> [0000096f](01) 5d pop ebp
>>> [00000970](01) c3 ret // final state.
>>> Size in bytes:(0027) [00000970]
>>>
>> A simulator is a machine code program. When you examine its "execution
>> trace" it looks nothing like the program it is simulating. You wouldn't
>> know that it was a simulator or which program it was simulating,
>> except by
>> a most exhaustive analysis.
>>
>> So it's not clear what you have done. However, in posts many months
>> ago, you
>> mentioned removing the simulator code itself from the execution traces.
>>
>> Since if you use a simulating halt decider and apply the H_Hat, H_Hat
>> construction to it, you get a nested series of simulations of
>> simulations, which
>> are eventually halted by the simulator, removing the simulator code
>> itself from
>> the execution traces makes it looks as though the code is caught in an
>> infinite
>> loop, when in fact it isn't.
>
> The simulated input does not need to be caught in an infinite loop, as
> long as it would never reach is own final state in an unlimited number
> of steps of simulation it fails to meet the Linz definition:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> thus making it a non-halting sequence of configurations.
>

Except that the correct simulation or execution of the input DOES halt
if H rejects it, so H's reject can not be correct.

Only H's INCORRECT simulation never reaches and end when H rejects its
input.

Yes, if Y doesn't reject its input, you can get a non-halting input, but
you don't get a counter example, as H didn't correctly answer the question.

Your logic is in error because you don't actually meet the requirements,
showing you are just ignorant of the basics of computer science and logic.

FAIL.

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

<Tp16K.213385$OT%7.194655@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer02.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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87k0bw4hgi.fsf@bsb.me.uk> <zJqdnWuS9-Zh8s7_nZ2dnUU7_81g4p2d@giganews.com>
<87r1632n6i.fsf@bsb.me.uk> <LeidnWJCD90dXcn_nZ2dnUU7_8xh4p2d@giganews.com>
<87a6cr2j8p.fsf@bsb.me.uk> <7_OdnfY0NISyScn_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 77
Message-ID: <Tp16K.213385$OT%7.194655@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: Thu, 14 Apr 2022 18:40:52 -0400
X-Received-Bytes: 5042
 by: Richard Damon - Thu, 14 Apr 2022 22:40 UTC

On 4/14/22 10:54 AM, olcott wrote:
> On 4/14/2022 9:30 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>
>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said
>>>>>> that
>>>>>> P(P) halts.  Oh, there is a third (c) you are using poetic
>>>>>> license, and
>>>>>> simulating the input means something silly.  It's literal nonsense to
>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>
>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>
>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>> That's not rhetoric.  You've been too clear about this attempt.  You
>>>> need to try a new ruse.
>>>
>>> Because the input to H(P,P) is non-halting then nothing in the
>>> universe can possibly contradict the fact that it is non-halting.
>>
>> Being generous, the "input" to H in the call H(P,P) is just two
>> pointers.  They are neither halting nor non-halting -- they are just
>> pointers.
>>
>> Up until, now I was prepared to take your words metaphorically, but
>> since you duck the key question of what "the input to H(P,P) is
>> non-halting" means,
>
> Sure when I make to to explain ever details many hundreds of times
> damned liars will say that I never mentioned any of this.
>
> The input to H is the only way that finite strings can be passed to a
> "C" function and points to the finite string of the machine code of P.
>
> The simulating halt decider H uses an x86 emulator to simulate its input
> (P,P) and finds that it would never reach its own final state in an
> unlimited number of simulated steps.
>
> This conclusively proves that this simulated input fails to match the
> Linz definition: computation that halts … the Turing machine will halt
> whenever it enters a final state. (Linz:1990:234)
>
>>  I will have start to take you are your word, though
>> I have still guessed what you mean by "input to H(P,P)".  I may have to
>> start replying that "H does no I/O" if you keep using the silly term
>> input.
>>
>> What we do know, for sure, is that H(P,P) == false even though P(P)
>> halts.  And that's wrong.  And I can keep saying that even if you never
>> explain your poetic use of language.
>>
>
>
> As long as the correctly simulated input to H(P,P) would never halt then
> we know it is non-halting.
>
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
>

But since the correctly simulated inpout to H(P,P) DOES HALT, as even
YOU have proven, to say the answer is non-halting is using unsound logic
and is just a LIE, and PROVES that you don't know what you are talking
about.

FAIL.

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

<Rq16K.213386$OT%7.86617@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com> <87r1632n6i.fsf@bsb.me.uk> <LeidnWJCD90dXcn_nZ2dnUU7_8xh4p2d@giganews.com> <87a6cr2j8p.fsf@bsb.me.uk> <7_OdnfY0NISyScn_nZ2dnUU7_8zNnZ2d@giganews.com> <87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com> <87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com> <87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com> <87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com> <87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com> <87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com> <87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com> <87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 83
Message-ID: <Rq16K.213386$OT%7.86617@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: Thu, 14 Apr 2022 18:41:54 -0400
X-Received-Bytes: 5081
 by: Richard Damon - Thu, 14 Apr 2022 22:41 UTC

On 4/14/22 1:14 PM, olcott wrote:
> On 4/14/2022 11:40 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>
>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have
>>>>>>>> said that
>>>>>>>> P(P) halts.  Oh, there is a third (c) you are using poetic
>>>>>>>> license, and
>>>>>>>> simulating the input means something silly.  It's literal
>>>>>>>> nonsense to
>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>
>>>>>>> When mere rhetoric goes against easily verified facts rhetoric
>>>>>>> loses:
>>>>>>
>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>>>> That's not rhetoric.  You've been too clear about this attempt.  You
>>>>>> need to try a new ruse.
>>>>>
>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>
>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>> pointers.  They are neither halting nor non-halting -- they are just
>>>> pointers.
>>>>
>>>> Up until, now I was prepared to take your words metaphorically, but
>>>> since you duck the key question of what "the input to H(P,P) is
>>>> non-halting" means,
>>>
>>> Sure when I make to to explain ever details many hundreds of times
>>> damned liars will say that I never mentioned any of this.
>>
>> Just use the right terms.  H(P,P) has not input.  The call has
>> arguments.  They are just pointers.  Pointers are not halting nor are
>> they non halting.  Given that this mantra is the core of what you are
>> now claiming, I would have thought you would want to avoid it being
>> patentent nonsense.
>>
>>> The input to H is the only way that finite strings can be passed to a
>>> "C" function and points to the finite string of the machine code of P.
>>
>> H has no input.  Do you mean the two pointer arguments?
>>
>>> The simulating halt decider H uses an x86 emulator to simulate its
>>> input (P,P) and finds that it would never reach its own final state in
>>> an unlimited number of simulated steps.
>>
>> (P,P) is too vague.  What needs to be simulated is the first pointer
>> being called as a function with the second as it's argument.  I.e. the
>> call P(P) is what should be simulated.
>>
>
> That the correctly simulated input to H(P,P) cannot possibly reach its
> own final state proves that this input is not-halting.

Are you forgetting that you actually proved it does reach its final
state by posting the trece of it?

>
> Adding all of the tedious details that you suggest does not change this
> fact.

So, you admit to being a LIAR?
>
>> We all know why you won't say this property.  You've said that H(P,P) ==
>> false even though P(P) halts, so you must obscure something or the game
>> is well and truly up.
>>
>
>

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

<As16K.213387$OT%7.82314@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87a6cr2j8p.fsf@bsb.me.uk> <7_OdnfY0NISyScn_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk> <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 230
Message-ID: <As16K.213387$OT%7.82314@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: Thu, 14 Apr 2022 18:43:45 -0400
X-Received-Bytes: 12044
 by: Richard Damon - Thu, 14 Apr 2022 22:43 UTC

On 4/14/22 6:16 PM, olcott wrote:
> On 4/14/2022 3:54 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>
>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have
>>>>>>>>>> said that
>>>>>>>>>> P(P) halts.  Oh, there is a third (c) you are using poetic
>>>>>>>>>> license, and
>>>>>>>>>> simulating the input means something silly.  It's literal
>>>>>>>>>> nonsense to
>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>
>>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric
>>>>>>>>> loses:
>>>>>>>>
>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P)
>>>>>>>> halts.
>>>>>>>> That's not rhetoric.  You've been too clear about this attempt.
>>>>>>>> You
>>>>>>>> need to try a new ruse.
>>>>>>>
>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>
>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>> pointers.  They are neither halting nor non-halting -- they are just
>>>>>> pointers.
>>>>>>
>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>> non-halting" means,
>>>>>
>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>> damned liars will say that I never mentioned any of this.
>>>> Just use the right terms.  H(P,P) has not input.  The call has
>>>> arguments.  They are just pointers.  Pointers are not halting nor are
>>>> they non halting.  Given that this mantra is the core of what you are
>>>> now claiming, I would have thought you would want to avoid it being
>>>> patentent nonsense.
>>>>
>>>>> The input to H is the only way that finite strings can be passed to a
>>>>> "C" function and points to the finite string of the machine code of P.
>>>> H has no input.  Do you mean the two pointer arguments?
>>>>
>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>> input (P,P) and finds that it would never reach its own final state in
>>>>> an unlimited number of simulated steps.
>>>>
>>>> (P,P) is too vague.  What needs to be simulated is the first pointer
>>>> being called as a function with the second as it's argument.  I.e. the
>>>> call P(P) is what should be simulated.
>>>
>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>> own final state proves that this input is not-halting.
>>>
>>> Adding all of the tedious details that you suggest does not change
>>> this fact.
>>
>> If you add all the corrections, sorry, "tedious details", it contradicts
>> what you've said in the past.  With the errors left in place, the naive
>> reader won't knowing exactly what's being said -- and I think that's
>> deliberate.
>>
>> For example, why talk about simulation at all since simulations of
>> computations halt or don't halt if and only if the computations do
>> themselves?  Well, it adds yet another puff of smoke to the mirrors
>> you've got in there already like what that "its" refers to (since
>> nothing here has a final state), or what non-halting pointers are.
>>
>> "The input to H(P,P)" should mean the two pointers, P and P.  Simulating
>> them should mean simulating the call P(P) and the simulation "not
>> reaching its own final state" should mean that the simulation of P(P)
>> does not halt.  And that happens if, and only if, the call P(P) itself
>> does not halt.
>>
>> I honestly have no idea if that is what you mean, but if it is, it's
>> wrong because P(P) halts.  You are probably just trying to cover that
>> up.
>>
>
> That a non input halts, converts the world to Fascism or opens a very
> popular brothel is totally unrelated to the easily confirmed fact that
> the input to H(P,P)* does not halt.

WHAT NON-INPUT.

>
> *standard functional notation
>
> _P()
> [00000956](01)  55              push ebp
> [00000957](02)  8bec            mov ebp,esp
> [00000959](03)  8b4508          mov eax,[ebp+08]
> [0000095c](01)  50              push eax       // push P
> [0000095d](03)  8b4d08          mov ecx,[ebp+08]
> [00000960](01)  51              push ecx       // push P
> [00000961](05)  e8c0feffff      call 00000826  // call H(P,P)
> The above keeps repeating until aborted

PROVING THAT YOU AREN'T LOOKING AT A CORRECT SIMULATION.

>
>
> [00000966](03)  83c408          add esp,+08
> [00000969](02)  85c0            test eax,eax
> [0000096b](02)  7402            jz 0000096f
> [0000096d](02)  ebfe            jmp 0000096d
> [0000096f](01)  5d              pop ebp
> [00000970](01)  c3              ret            // final state.
> Size in bytes:(0027) [00000970]
>
>
>

Here is your previously posted CORRECT SIMULATION:

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped


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

<zt16K.213388$OT%7.179258@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.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>
<87bkxb9tc9.fsf@bsb.me.uk> <h4ydnXCGgtZONs3_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<87ilrh7tr3.fsf@bsb.me.uk> <74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk> <op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk> <NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk> <N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk> <H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me> <X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me> <mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me> <V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk> <77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 38
Message-ID: <zt16K.213388$OT%7.179258@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: Thu, 14 Apr 2022 18:44:48 -0400
X-Received-Bytes: 3348
 by: Richard Damon - Thu, 14 Apr 2022 22:44 UTC

On 4/14/22 10:43 AM, olcott wrote:
> On 4/14/2022 8:33 AM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/13/2022 10:56 PM, André G. Isaak wrote:
>>
>>>> Does your H actually exist, or is this just something you've been
>>>> making up? The above certainly doesn't correspond to you description
>>>> of a simulating halt decider.
>>>
>>> It exists as fully operational code for a long time now, more than a
>>> year.
>>
>> Why did it take you so long?  18 years ago you wrote:
>>
>>    "I have correctly refuted each and every mechanism by which the
>>    [above] statement has been proven to be true. I have not shown that
>>    solving the Halting Problem is possible, merely refuted every proof
>>    that it is impossible."
>>
>> but somehow it took until last year to write an H such that gets the key
>> case wrong?  An H that returns false for the key case is not hard to
>> write!
>>
>
> As long as the correctly simulated input to H(P,P) would never halt then
> we know it is non-halting.
>
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
>

But the initial premise isn't true, teh correctly simulated input halts.

Thus YOU are the liar and user of UNSOUND logic.

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

<kw16K.213389$OT%7.89071@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer01.ams4!peer.am4.highwinds-media.com!peer03.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>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<87ilrh7tr3.fsf@bsb.me.uk> <74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk> <op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk> <NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk> <N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk> <H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me> <X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me> <mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me> <V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk> <77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
<878rs7s92t.fsf@bsb.me.uk> <8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 161
Message-ID: <kw16K.213389$OT%7.89071@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: Thu, 14 Apr 2022 18:47:46 -0400
X-Received-Bytes: 8905
 by: Richard Damon - Thu, 14 Apr 2022 22:47 UTC

On 4/14/22 4:41 PM, olcott wrote:
> On 4/14/2022 3:28 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> As long as the correctly simulated input to H(P,P) would never halt
>>> then we know it is non-halting.
>>
>> Readers beware!  Ask yourselves why PO does not say the simpler "never
>> halts", but instead says "/would/ never halt".  Why the implied
>> subjunctive mood?
>
> A simulating halt decider must correctly predict the future behavior of
> of its simulated input. Many of my readers get confused and believe that
> an aborted simulation means that the simulated input has halted.

Nope. abortef simulation means that the simulation is incomplete and
thus not correct.

To get the truth you need to look at the correct, that is, non-aborted
simulation.

>
> To an academic audience of computer scientists I would simply say that
> the behavior of the simulated input to H(P,P) conclusively proves that
> it is non-halting.

Nope, it used unsound logic. The logic starts with the premise that
H(P,P) never aborts, and then H(P,P) aborts, thus invalidating the
assumption.

>
> They would recognize the functional notation of H(P,P) indicating its
> input as is standard functional notation for all functions.
>
> _P()
> [00000956](01)  55              push ebp
> [00000957](02)  8bec            mov ebp,esp
> [00000959](03)  8b4508          mov eax,[ebp+08]
> [0000095c](01)  50              push eax       // push P
> [0000095d](03)  8b4d08          mov ecx,[ebp+08]
> [00000960](01)  51              push ecx       // push P
> [00000961](05)  e8c0feffff      call 00000826  // call H(P,P)
> The above keeps repeating until aborted

Thus proving this isn't the correct simulation, since correct simulation
don't abort.

>
> [00000966](03)  83c408          add esp,+08
> [00000969](02)  85c0            test eax,eax
> [0000096b](02)  7402            jz 0000096f
> [0000096d](02)  ebfe            jmp 0000096d
> [0000096f](01)  5d              pop ebp
> [00000970](01)  c3              ret            // final state.
> Size in bytes:(0027) [00000970]
>
>

Here is your previously posted CORRECT simulation:

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)

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

<%x16K.213390$OT%7.71092@fx07.iad>

 copy mid

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

 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!peer03.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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<I5KdnSVY8pdCG8r_nZ2dnUU7_8zNnZ2d@giganews.com>
<3f2e6908-8a31-4cd2-b6b5-d2bc155cd92cn@googlegroups.com>
<I5KdnSRY8perFcr_nZ2dnUU7_8xh4p2d@giganews.com>
<346bc4f2-37f6-4b50-88a2-0d0585a72456n@googlegroups.com>
<_rSdnZNXUoDvFsr_nZ2dnUU7_8xh4p2d@giganews.com>
<f9a2fa84-9b92-4a78-8080-642f84f60558n@googlegroups.com>
<36udnR0ZM4ihEMr_nZ2dnUU7_8xh4p2d@giganews.com>
<0473bee1-bd4b-4e09-9f29-f928f7b0e47fn@googlegroups.com>
<mdSdnSErnKmXDcr_nZ2dnUU7_8zNnZ2d@giganews.com>
<f70d6e89-5fe4-4e4c-b7a8-52efeba6e22cn@googlegroups.com>
<bs2dnbLYgLTrDMr_nZ2dnUU7_8zNnZ2d@giganews.com>
<e1a3f5df-93e6-4b02-823f-739eb49417f1n@googlegroups.com>
<v_-dnfRAdeowCcr_nZ2dnUU7_8xh4p2d@giganews.com>
<ca64aa02-662a-4cb4-b528-da2109066335n@googlegroups.com>
<ieidnfSoTfZdCsr_nZ2dnUU7_8zNnZ2d@giganews.com>
<7891db88-8b20-4fed-a88f-a2aeb51795e1n@googlegroups.com>
<77mdnb2uM9hDr8X_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <77mdnb2uM9hDr8X_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 540
Message-ID: <%x16K.213390$OT%7.71092@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: Thu, 14 Apr 2022 18:49:32 -0400
X-Received-Bytes: 30482
 by: Richard Damon - Thu, 14 Apr 2022 22:49 UTC

On 4/14/22 10:42 AM, olcott wrote:
> On 4/14/2022 6:55 AM, Dennis Bush wrote:
>> On Wednesday, April 13, 2022 at 11:40:55 PM UTC-4, olcott wrote:
>>> On 4/13/2022 10:33 PM, Dennis Bush wrote:
>>>> On Wednesday, April 13, 2022 at 11:27:49 PM UTC-4, olcott wrote:
>>>>> On 4/13/2022 10:16 PM, Dennis Bush wrote:
>>>>>> On Wednesday, April 13, 2022 at 11:14:05 PM UTC-4, olcott wrote:
>>>>>>> On 4/13/2022 10:09 PM, Dennis Bush wrote:
>>>>>>>> On Wednesday, April 13, 2022 at 11:08:02 PM UTC-4, olcott wrote:
>>>>>>>>> On 4/13/2022 10:03 PM, Dennis Bush wrote:
>>>>>>>>>> On Wednesday, April 13, 2022 at 10:56:03 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 4/13/2022 9:50 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:48:25 PM UTC-4, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 4/13/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:34:37 PM UTC-4, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 4/13/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:28:54 PM UTC-4,
>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>> On 4/13/2022 9:14 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:06:03 PM UTC-4,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/13/2022 6:45 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:35:34 PM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:25 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:23:46 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:17:52 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:15 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:09:11 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:59:47 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:56 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:53:05 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:13 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:06:02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 7:49 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 8:06 AM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 8:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 6:55 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:05 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:18 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The truth is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by who does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not agree with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something. But to find the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth of the matter you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must first stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking literal nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The arguments to H (what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you call the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "input") are two pointers.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What does simulating two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointers mean?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What you mean, I hope, is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating calling the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first pointer with the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> second as it's argument.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That simulation, according
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, will halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (or "reach it's final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state" in your flamboyant,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sciencey, language).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It will halt because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct call P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Everything here halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (according to you). That's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> why H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply are ignoring the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual execution trace that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The traces that matter are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the one of P(P) halting (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> made the mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of posting it once), and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one of H(P,P) return false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you posted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as well). You a free to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract any of these at any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time, but until you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, your H is wrong by your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own supplied traces.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is never the case that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Waffle. HP(P) halts so (P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> == false is wrong. You can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typo: "so H(P,P) == false is wrong"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these facts (since they come
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from you in the first place).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then, you've told us that your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine address, no waffle
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there merely an easily verified
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can verify a thousand more
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant facts. The facts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are already known: that P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts and that H(P,P) == false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presenting any verified facts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that corrects this mistake? If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so, just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say and I'll stop quoting it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by P(P) intuitively seems
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> like it must be identical to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P). It turns out that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intuition is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So which fact are you retracting?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That P(P) halts or that H(P,P) ==
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then we know that it never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if everyone in the universe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you plan to keep posting the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sentence in an attempt to take
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the focus off the fact that H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obviously wrong?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then you must mean
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHOOP! WHOOP! WHOOP! Danger Will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Robinson.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You should avoid trying to paraphrase
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other people. Your replies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> suggest you don't often understand the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various points being put to you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so when you try to re-word them the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> results are usually bogus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a correctly simulated input that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reaches its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state is still a computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I meant what I said. If you are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure that I meant, asking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> well-chosen questions about it is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way to go.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know [by definition] that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a halting computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting is incorrect?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to H(P,P) does reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As a matter of fact it does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The simulated input to H(P,P) cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it keeps repeating [00000956] to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961] until aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000956](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095c](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000960](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961](05) e8c0feffff call 00000826
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above keeps repeating until aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096f](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000970](01) c3 ret // final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And when Hb simulates this input, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches a final state. Therefore H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong to report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A dishonest attempt at the strawman fallacy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bill up the street did not rob the liquor
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> store I know this because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other guy that I know named Bill was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> watching TV at the time of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> robbery.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words you have no rebuttal
>>>>>>>>>>>>>>>>>>>>>>>>>>>> because you know that Hb(P,P) == true is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and proves that H(P,P)==false is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Hb(P,P) is off topic because it proves
>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing and you know that it
>>>>>>>>>>>>>>>>>>>>>>>>>>> proves nothing and is just a disgusting
>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt at a head game.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is not off topic because it directly
>>>>>>>>>>>>>>>>>>>>>>>>>> contradicts your desired result. That you
>>>>>>>>>>>>>>>>>>>>>>>>>> haven't explained why it's wrong is a
>>>>>>>>>>>>>>>>>>>>>>>>>> confirmation of this.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That is why I focus on the X proves Y
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (X) We can verify that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) fails to meet the
>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters
>>>>>>>>>>>>>>>>>>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FALSE, because an incorrect simulation is not
>>>>>>>>>>>>>>>>>>>>>>>>>> the same as a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (Y) When H(P,P) returns false it is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FALSE, as proved by Hb(P,P) returning true for
>>>>>>>>>>>>>>>>>>>>>>>>>> the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I CAN'T POSSIBLY BE WRONG UNLESS THERE IS AN
>>>>>>>>>>>>>>>>>>>>>>>>>>> ESSENTIAL MISTAKE IN X OR Y.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulated input to H(P,P) fails to meet
>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of halting, then Ha3(N,5) also
>>>>>>>>>>>>>>>>>>>>>>>>>> fails to meet that same definition of halting.
>>>>>>>>>>>>>>>>>>>>>>>>>> So that along shows that your criteria is bogus.
>>>>>>>>>>>>>>>>>>>>>>>>> I can see that you don't want this dialogue to
>>>>>>>>>>>>>>>>>>>>>>>>> continue.
>>>>>>>>>>>>>>>>>>>>>>>>> I will not tolerate head games.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Translation:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "I will not tolerate arguments that conclusively
>>>>>>>>>>>>>>>>>>>>>>>> prove me wrong because I can't bear the though
>>>>>>>>>>>>>>>>>>>>>>>> of having wasted the last 17 years".
>>>>>>>>>>>>>>>>>>>>>>> You are trying to prove that Bill Smith is not
>>>>>>>>>>>>>>>>>>>>>>> guilty because Bill Jones
>>>>>>>>>>>>>>>>>>>>>>> didn't do it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Another bad analogy. Further proof that you have
>>>>>>>>>>>>>>>>>>>>>> no rebuttal.
>>>>>>>>>>>>>>>>>>>>> That H(P,P)==false is correct is true by logical
>>>>>>>>>>>>>>>>>>>>> necessity.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, that Hb(P,P)==true is correct by logical necessity.
>>>>>>>>>>>>>>>>>>> I will dumb it down for you: (Do not not believe in
>>>>>>>>>>>>>>>>>>> tautologies ?)
>>>>>>>>>>>>>>>>>>> Because the input to H(P,P) is non-halting
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Which is isn't as Hb demonstrates
>>>>>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I see you didn't bother to explain why my explanation is
>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>> If an X <is a> Y and Dennis disagrees then Dennis is a liar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Still no explanation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> It is a verified fact that the input to H(P,P) is
>>>>>>>>>>>>> non-halting and Dennis
>>>>>>>>>>>>> denies this therefore Dennis is a liar. Is it fun being a
>>>>>>>>>>>>> liar?
>>>>>>>>>>>>
>>>>>>>>>>>> It is a verified fact that the input to H(P,P) is *halting*
>>>>>>>>>>>> as follows:
>>>>>>>>>>> Liar !
>>>>>>>>>>
>>>>>>>>>> This just shows everyone reading not only that you're wrong,
>>>>>>>>>> but that you know it.
>>>>>>>>> If an X is a Y and you deny it then you are a liar.
>>>>>>>>> The simulated input to H(P,P) is non-halting and you know it.
>>>>>>>>> Is it fun being a liar?
>>>>>>>>
>>>>>>>> You're really struggling with this aren't you?
>>>>>>>>
>>>>>>> I am not struggling with the fact that you are having fun being a
>>>>>>> liar.
>>>>>>>
>>>>>>> Unlike everyone else I have a direct measure of your competence,
>>>>>>> so you
>>>>>>> can't fool me about what you don't understand.
>>>>>>
>>>>>> Then you should have no problem explaining EXACTLY why this is wrong:
>>>>>>
>>>>>>
>>>>>> The simulated input does reach a final state when simulated by Hb.
>>>>>>
>>>>>> _P()
>>>>>> [00000956](01) 55 push ebp
>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>> [0000095c](01) 50 push eax // push P
>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00000960](01) 51 push ecx // push P
>>>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>>>> //The above returns false
>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>> [0000096f](01) 5d pop ebp
>>>>>> [00000970](01) c3 ret // final state.
>>>>>> // Hb reaches the final state of its input
>>>>>>
>>>>>> Hb and H are both simulating halt deciders and are given the same
>>>>>> input so
>>>>>> both are answering the exact same question but get different results,
>>>>> As long as the correctly simulated input to H(P,P) would never halt
>>>>> then
>>>>> we know it is non-halting.
>>>>
>>>> You just keep repeating with no explanation that H(P,P)==false is
>>>> correct. I explain it detail why it's not.
>>>>
>>>> Hb demonstrates that the correctly simulated input to H(P,P) i.e.
>>>> (P,P) DOES halt. So find an error:
>>>>
>>>> _P()
>>>> [00000956](01) 55 push ebp
>>>> [00000957](02) 8bec mov ebp,esp
>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>> [0000095c](01) 50 push eax // push P
>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000960](01) 51 push ecx // push P
>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>> //The above returns false
>>>> [00000966](03) 83c408 add esp,+08
>>>> [00000969](02) 85c0 test eax,eax
>>>> [0000096b](02) 7402 jz 0000096f
>>>> [0000096d](02) ebfe jmp 0000096d
>>>> [0000096f](01) 5d pop ebp
>>>> [00000970](01) c3 ret // final state.
>>>> // Hb reaches the final state of its input
>>>>
>>> ONE OF THESE ASSUMPTIONS MUST BE INCORRECT* BECAUSE IT CONTRADICTS
>>> LOGICAL NECESSITY (*It doesn't freaking matter which one).
>>>> Hb and H are both simulating halt deciders
>>>> and are given the same input so both are
>>>> answering the exact same question but get
>>>> different results, so one must be wrong. correct.
>>> As long as the correctly simulated input to H(P,P) would never halt then
>>> we know it is non-halting.
>>
>> Obviously, *if* the correctly simulated input to H(P,P) would never
>> halt then we know it is non-halting.  The problem is the correctly
>> simulated input DOES halt.
>>
> Is it fun to be a liar?
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> The simulated input to H(P,P) cannot possibly reach its own final state
> it keeps repeating [00000956] to [00000961] until aborted.


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

<mA16K.213391$OT%7.75217@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.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 ] H(P,P)
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<E-2dnVtqXuBi2cv_nZ2dnUU7_83NnZ2d@giganews.com>
<04ecb792-c7df-4e86-988b-f49c1cf50432n@googlegroups.com>
<TvqdnSWvLfIZHMr_nZ2dnUU7_83NnZ2d@giganews.com>
<7b81816c-4864-4357-917b-a111f9abb626n@googlegroups.com>
<I5KdnSVY8pdCG8r_nZ2dnUU7_8zNnZ2d@giganews.com>
<3f2e6908-8a31-4cd2-b6b5-d2bc155cd92cn@googlegroups.com>
<I5KdnSRY8perFcr_nZ2dnUU7_8xh4p2d@giganews.com>
<346bc4f2-37f6-4b50-88a2-0d0585a72456n@googlegroups.com>
<_rSdnZNXUoDvFsr_nZ2dnUU7_8xh4p2d@giganews.com>
<f9a2fa84-9b92-4a78-8080-642f84f60558n@googlegroups.com>
<36udnR0ZM4ihEMr_nZ2dnUU7_8xh4p2d@giganews.com>
<0473bee1-bd4b-4e09-9f29-f928f7b0e47fn@googlegroups.com>
<mdSdnSErnKmXDcr_nZ2dnUU7_8zNnZ2d@giganews.com>
<f70d6e89-5fe4-4e4c-b7a8-52efeba6e22cn@googlegroups.com>
<bs2dnbLYgLTrDMr_nZ2dnUU7_8zNnZ2d@giganews.com>
<e1a3f5df-93e6-4b02-823f-739eb49417f1n@googlegroups.com>
<t39nqp$1vjj$1@gioia.aioe.org>
<k4idnUci9fPV-8X_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <k4idnUci9fPV-8X_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 369
Message-ID: <mA16K.213391$OT%7.75217@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: Thu, 14 Apr 2022 18:52:04 -0400
X-Received-Bytes: 22027
 by: Richard Damon - Thu, 14 Apr 2022 22:52 UTC

On 4/14/22 2:21 PM, olcott wrote:
> On 4/14/2022 1:06 PM, Mike Terry wrote:
>> On 14/04/2022 04:16, Dennis Bush wrote:
>>> On Wednesday, April 13, 2022 at 11:14:05 PM UTC-4, olcott wrote:
>>>> On 4/13/2022 10:09 PM, Dennis Bush wrote:
>>>>> On Wednesday, April 13, 2022 at 11:08:02 PM UTC-4, olcott wrote:
>>>>>> On 4/13/2022 10:03 PM, Dennis Bush wrote:
>>>>>>> On Wednesday, April 13, 2022 at 10:56:03 PM UTC-4, olcott wrote:
>>>>>>>> On 4/13/2022 9:50 PM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, April 13, 2022 at 10:48:25 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/13/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:34:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 4/13/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:28:54 PM UTC-4, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 4/13/2022 9:14 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:06:03 PM UTC-4, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 4/13/2022 6:45 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:35:34 PM UTC-4, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 4/12/2022 10:25 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:23:46 PM UTC-4,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:17:52 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:15 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:09:11 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:59:47 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:56 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:53:05 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:13 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:06:02 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 7:49 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 8:06 AM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 8:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 6:55 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:05 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:18 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The truth is not determined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by who does or does not agree
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something. But to find the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth of the matter you must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking literal nonsense. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments to H (what you call
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "input") are two pointers.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What does simulating two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointers mean?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What you mean, I hope, is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating calling the first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointer with the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> second as it's argument. That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, according to you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (or "reach it's final state"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in your flamboyant, sciencey,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It will halt because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct call P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Everything here halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (according to you). That's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> why H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply are ignoring the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual execution trace that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The traces that matter are the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one of P(P) halting (you made
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of posting it once), and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one of H(P,P) return false (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as well). You a free to retract
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of these at any time, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, your H is wrong by your own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> supplied traces.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is never the case that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to H(P,P) ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Waffle. HP(P) halts so (P,P) ==
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false is wrong. You can retract
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typo: "so H(P,P) == false is wrong"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these facts (since they come from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you in the first place). Until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then, you've told us that your H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that the simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never reaches its [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine address, no waffle there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely an easily verified fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can verify a thousand more
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant facts. The facts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are already known: that P(P) halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and that H(P,P) == false. Are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presenting any verified facts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> corrects this mistake? If so, just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say and I'll stop quoting it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by P(P) intuitively seems
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> like it must be identical to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P). It turns out that intuition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So which fact are you retracting?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That P(P) halts or that H(P,P) ==
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then we know that it never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if everyone in the universe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you plan to keep posting the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sentence in an attempt to take
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the focus off the fact that H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obviously wrong?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then you must mean
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHOOP! WHOOP! WHOOP! Danger Will Robinson.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You should avoid trying to paraphrase
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other people. Your replies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> suggest you don't often understand the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various points being put to you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so when you try to re-word them the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> results are usually bogus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a correctly simulated input that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reaches its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state is still a computation that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I meant what I said. If you are not sure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I meant, asking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> well-chosen questions about it is the way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know [by definition] that a correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting is incorrect?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to H(P,P) does reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As a matter of fact it does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The simulated input to H(P,P) cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> it keeps repeating [00000956] to [00000961]
>>>>>>>>>>>>>>>>>>>>>>>>>>>> until aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000956](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095c](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000960](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961](05) e8c0feffff call 00000826 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>> call H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above keeps repeating until aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096f](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000970](01) c3 ret // final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And when Hb simulates this input, it reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>> a final state. Therefore H is wrong to report
>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>> A dishonest attempt at the strawman fallacy.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Bill up the street did not rob the liquor
>>>>>>>>>>>>>>>>>>>>>>>>>> store I know this because the
>>>>>>>>>>>>>>>>>>>>>>>>>> other guy that I know named Bill was watching
>>>>>>>>>>>>>>>>>>>>>>>>>> TV at the time of the
>>>>>>>>>>>>>>>>>>>>>>>>>> robbery.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So in other words you have no rebuttal because
>>>>>>>>>>>>>>>>>>>>>>>>> you know that Hb(P,P) == true is correct and
>>>>>>>>>>>>>>>>>>>>>>>>> proves that H(P,P)==false is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>> Hb(P,P) is off topic because it proves nothing
>>>>>>>>>>>>>>>>>>>>>>>> and you know that it
>>>>>>>>>>>>>>>>>>>>>>>> proves nothing and is just a disgusting attempt
>>>>>>>>>>>>>>>>>>>>>>>> at a head game.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is not off topic because it directly
>>>>>>>>>>>>>>>>>>>>>>> contradicts your desired result. That you haven't
>>>>>>>>>>>>>>>>>>>>>>> explained why it's wrong is a confirmation of this.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> That is why I focus on the X proves Y
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (X) We can verify that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) fails to meet the
>>>>>>>>>>>>>>>>>>>>>>>> Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>>>>>> halt whenever it enters
>>>>>>>>>>>>>>>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FALSE, because an incorrect simulation is not the
>>>>>>>>>>>>>>>>>>>>>>> same as a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (Y) When H(P,P) returns false it is correct.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FALSE, as proved by Hb(P,P) returning true for
>>>>>>>>>>>>>>>>>>>>>>> the same input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I CAN'T POSSIBLY BE WRONG UNLESS THERE IS AN
>>>>>>>>>>>>>>>>>>>>>>>> ESSENTIAL MISTAKE IN X OR Y.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If the simulated input to H(P,P) fails to meet
>>>>>>>>>>>>>>>>>>>>>>> the definition of halting, then Ha3(N,5) also
>>>>>>>>>>>>>>>>>>>>>>> fails to meet that same definition of halting. So
>>>>>>>>>>>>>>>>>>>>>>> that along shows that your criteria is bogus.
>>>>>>>>>>>>>>>>>>>>>> I can see that you don't want this dialogue to
>>>>>>>>>>>>>>>>>>>>>> continue.
>>>>>>>>>>>>>>>>>>>>>> I will not tolerate head games.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Translation:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> "I will not tolerate arguments that conclusively
>>>>>>>>>>>>>>>>>>>>> prove me wrong because I can't bear the though of
>>>>>>>>>>>>>>>>>>>>> having wasted the last 17 years".
>>>>>>>>>>>>>>>>>>>> You are trying to prove that Bill Smith is not
>>>>>>>>>>>>>>>>>>>> guilty because Bill Jones
>>>>>>>>>>>>>>>>>>>> didn't do it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Another bad analogy. Further proof that you have no
>>>>>>>>>>>>>>>>>>> rebuttal.
>>>>>>>>>>>>>>>>>> That H(P,P)==false is correct is true by logical
>>>>>>>>>>>>>>>>>> necessity.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, that Hb(P,P)==true is correct by logical necessity.
>>>>>>>>>>>>>>>> I will dumb it down for you: (Do not not believe in
>>>>>>>>>>>>>>>> tautologies ?)
>>>>>>>>>>>>>>>> Because the input to H(P,P) is non-halting
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which is isn't as Hb demonstrates
>>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>
>>>>>>>>>>>>> I see you didn't bother to explain why my explanation is
>>>>>>>>>>>>> wrong.
>>>>>>>>>>>> If an X <is a> Y and Dennis disagrees then Dennis is a liar.
>>>>>>>>>>>
>>>>>>>>>>> Still no explanation.
>>>>>>>>>>>
>>>>>>>>>> It is a verified fact that the input to H(P,P) is non-halting
>>>>>>>>>> and Dennis
>>>>>>>>>> denies this therefore Dennis is a liar. Is it fun being a liar?
>>>>>>>>>
>>>>>>>>> It is a verified fact that the input to H(P,P) is *halting* as
>>>>>>>>> follows:
>>>>>>>> Liar !
>>>>>>>
>>>>>>> This just shows everyone reading not only that you're wrong, but
>>>>>>> that you know it.
>>>>>> If an X is a Y and you deny it then you are a liar.
>>>>>> The simulated input to H(P,P) is non-halting and you know it.
>>>>>> Is it fun being a liar?
>>>>>
>>>>> You're really struggling with this aren't you?
>>>>>
>>>> I am not struggling with the fact that you are having fun being a liar.
>>>>
>>>> Unlike everyone else I have a direct measure of your competence, so you
>>>> can't fool me about what you don't understand.
>>>
>>> Then you should have no problem explaining EXACTLY why this is wrong:
>>>
>>>
>>> The simulated input does reach a final state when simulated by Hb.
>>>
>>> _P()
>>> [00000956](01) 55 push ebp
>>> [00000957](02) 8bec mov ebp,esp
>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>> [0000095c](01) 50 push eax // push P
>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000960](01) 51 push ecx // push P
>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>> //The above returns false
>>> [00000966](03) 83c408 add esp,+08
>>> [00000969](02) 85c0 test eax,eax
>>> [0000096b](02) 7402 jz 0000096f
>>> [0000096d](02) ebfe jmp 0000096d
>>> [0000096f](01) 5d pop ebp
>>> [00000970](01) c3 ret // final state.
>>> // Hb reaches the final state of its input
>>>
>>> Hb and H are both simulating halt deciders and are given the same
>>> input so both are answering the exact same question but get different
>>> results, so one must be wrong. H makes an abort decision and leaves
>>> UTM mode to abort. Hb *never* leaves UTM mode and simulates the input
>>> to a final state.
>>>
>>> Therefore Hb(P,P)==true is correct, proving that H(P,P)==false is
>>> incorrect.
>>>
>>
>> PO published his own trace about a year ago, where he actually showed
>> P(P) halting!  (I suspect it was an accident, and he forgot to
>> manually delete the end of the trace.)
> The fact that the correct simulation of the input to H(P,P) would never
> reach its own final state conclusively proves that this input is
> non-halting and nothing in the universe can possibly contradict this.


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

<87r15zqkmq.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]
Date: Fri, 15 Apr 2022 01:02:21 +0100
Organization: A noiseless patient Spider
Lines: 61
Message-ID: <87r15zqkmq.fsf@bsb.me.uk>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ilrh7tr3.fsf@bsb.me.uk>
<74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk>
<op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk>
<NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk>
<N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk>
<H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me>
<X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me>
<mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me>
<V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk>
<77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
<878rs7s92t.fsf@bsb.me.uk>
<8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="f8b67a7155e27a25649c34539ea91f50";
logging-data="24422"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/kmJ4NlBjakq7OvWSrkDbPjAzSGwe7Nws="
Cancel-Lock: sha1:RWycQOkrlaQqhUrs5tFr/7aFKGg=
sha1:kRXEHz2JmL72TVrsefcp1xwaeWQ=
X-BSB-Auth: 1.09f71d1272c238226260.20220415010221BST.87r15zqkmq.fsf@bsb.me.uk
 by: Ben - Fri, 15 Apr 2022 00:02 UTC

olcott <NoOne@NoWhere.com> writes:

> On 4/14/2022 3:28 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> As long as the correctly simulated input to H(P,P) would never halt
>>> then we know it is non-halting.
>>
>> Readers beware! Ask yourselves why PO does not say the simpler "never
>> halts", but instead says "/would/ never halt". Why the implied
>> subjunctive mood?
>
> A simulating halt decider must correctly predict the future behavior
> of of its simulated input.

But that's not what the implied subjunctive is about. We know what it's
about because you've been clear in the past. You need to justify the
wrong answer (false) for a halting computation. What to do? Being
clear got you nowhere, so now you rely on bad wording and simply
implying the if: "as long as ... would never halt if it were not
halted".

If it's deliberate rather than just being bad writing, then it's quite a
clever way to hide the trick -- especially as you sometimes leave the
'would' out just to keep people guessing.

Unfortunately, being shy about what you mean to say does not really
help, because H(P,P)==false is still wrong because P(P) halts. I think
you have to be explicit or people will just say the simulation is wrong.
That's why the good old days of "it only halts because..." and "it
wouldn't halt if line 15 were commented out" where better. Still junk,
but less deception.

> Many of my readers get confused and believe that
> an aborted simulation means that the simulated input has halted.

That's more like it! Stand up for the nonsense you believe in! Don't
hide it behind weasel words! P(P) halts but only because it had to be
stopped, so it's not really a halting computation!

Take pride in the utter daftness of claims like these:

"the fact [that] a computation stops running does not prove that it
halts"

"the fact that a computation halts does not entail that it is a
halting computation"

We all need some light relief in difficult times.

> To an academic audience of computer scientists I would simply say that
> the behavior of the simulated input to H(P,P) conclusively proves that
> it is non-halting.

You are funny!

I'd pay real money to see you attempt to get this guff past a room full of
university CS staff. I'd pay more if it could have been when I was one
of them.

--
Ben.

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

<87lew7qk6k.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ] H(P,P)
Date: Fri, 15 Apr 2022 01:12:03 +0100
Organization: A noiseless patient Spider
Lines: 99
Message-ID: <87lew7qk6k.fsf@bsb.me.uk>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk>
<IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk>
<EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk>
<acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk>
<B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk>
<9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk>
<hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk>
<yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk>
<apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk>
<q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk>
<YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="f8b67a7155e27a25649c34539ea91f50";
logging-data="24422"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Tv4mdhQyuna3+9urN2+6uzq/sXEerFrI="
Cancel-Lock: sha1:szD7At9ZeboPUOfO8KU/PR1qb0c=
sha1:DNurAAB0XRAP+Xb1NovWzkeulCk=
X-BSB-Auth: 1.e81e38133b4819862090.20220415011203BST.87lew7qk6k.fsf@bsb.me.uk
 by: Ben - Fri, 15 Apr 2022 00:12 UTC

olcott <NoOne@NoWhere.com> writes:

> On 4/14/2022 3:54 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>
>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said that
>>>>>>>>>> P(P) halts. Oh, there is a third (c) you are using poetic license, and
>>>>>>>>>> simulating the input means something silly. It's literal nonsense to
>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>
>>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>>>>>
>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>>>>>> That's not rhetoric. You've been too clear about this attempt. You
>>>>>>>> need to try a new ruse.
>>>>>>>
>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>
>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>> pointers. They are neither halting nor non-halting -- they are just
>>>>>> pointers.
>>>>>>
>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>> non-halting" means,
>>>>>
>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>> damned liars will say that I never mentioned any of this.
>>>> Just use the right terms. H(P,P) has not input. The call has
>>>> arguments. They are just pointers. Pointers are not halting nor are
>>>> they non halting. Given that this mantra is the core of what you are
>>>> now claiming, I would have thought you would want to avoid it being
>>>> patentent nonsense.
>>>>
>>>>> The input to H is the only way that finite strings can be passed to a
>>>>> "C" function and points to the finite string of the machine code of P.
>>>> H has no input. Do you mean the two pointer arguments?
>>>>
>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>> input (P,P) and finds that it would never reach its own final state in
>>>>> an unlimited number of simulated steps.
>>>>
>>>> (P,P) is too vague. What needs to be simulated is the first pointer
>>>> being called as a function with the second as it's argument. I.e. the
>>>> call P(P) is what should be simulated.
>>>
>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>> own final state proves that this input is not-halting.
>>>
>>> Adding all of the tedious details that you suggest does not change
>>> this fact.
>>
>> If you add all the corrections, sorry, "tedious details", it contradicts
>> what you've said in the past. With the errors left in place, the naive
>> reader won't knowing exactly what's being said -- and I think that's
>> deliberate.
>>
>> For example, why talk about simulation at all since simulations of
>> computations halt or don't halt if and only if the computations do
>> themselves? Well, it adds yet another puff of smoke to the mirrors
>> you've got in there already like what that "its" refers to (since
>> nothing here has a final state), or what non-halting pointers are.
>> "The input to H(P,P)" should mean the two pointers, P and P. Simulating
>> them should mean simulating the call P(P) and the simulation "not
>> reaching its own final state" should mean that the simulation of P(P)
>> does not halt. And that happens if, and only if, the call P(P) itself
>> does not halt.
>>
>> I honestly have no idea if that is what you mean, but if it is, it's
>> wrong because P(P) halts. You are probably just trying to cover that
>> up.
>
> That a non input halts, converts the world to Fascism or opens a very
> popular brothel is totally unrelated to the easily confirmed fact that
> the input to H(P,P)* does not halt.

The correct value of H(P,P) is determined by the halting status of what
you call a non input: the function call P(P). You don't get to say
otherwise. That's the definition of the function that can't be written.
You can't back out of that just because you've realised you can't meet
the specification.

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ liar by definition ]

<P82dncpZ0YJgJcX_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: 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: Thu, 14 Apr 2022 19:14:53 -0500
Date: Thu, 14 Apr 2022 19:14: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) [
liar by definition ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ilrh7tr3.fsf@bsb.me.uk> <74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk> <op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk> <NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk> <N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk> <H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me> <X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me> <mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me> <V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk> <77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
<878rs7s92t.fsf@bsb.me.uk> <8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87r15zqkmq.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <87r15zqkmq.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <P82dncpZ0YJgJcX_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 35
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-aSPqYmPbCXX7arvkF1sjhefC+LYla1VWnxmMXAMq+ZLM3fQALLdifmf5YHJSrcpPOLqfipDbULNIg0A!F+M+XhZyv6k/vcWMncvEPgnR67MEo2oZ3zN5jJavhmFbt/p/TSbrS/pYU+9x5/I4KxVO64nMdAxp
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: 3397
 by: olcott - Fri, 15 Apr 2022 00:14 UTC

On 4/14/2022 7:02 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/14/2022 3:28 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> As long as the correctly simulated input to H(P,P) would never halt
>>>> then we know it is non-halting.
>>>
>>> Readers beware! Ask yourselves why PO does not say the simpler "never
>>> halts", but instead says "/would/ never halt". Why the implied
>>> subjunctive mood?
>>
>> A simulating halt decider must correctly predict the future behavior
>> of of its simulated input.
>
> But that's not what the implied subjunctive is about. We know what it's
> about because you've been clear in the past. You need to justify the
> wrong answer (false) for a halting computation.

As long as the correctly simulated input to H(P,P) would never halt then
we know it is non-halting.

Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.

--
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) [ liar by definition ]

<P82dncVZ0YIPJMX_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: 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: Thu, 14 Apr 2022 19:17:22 -0500
Date: Thu, 14 Apr 2022 19:17:22 -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) [
liar by definition ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk> <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87lew7qk6k.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <P82dncVZ0YIPJMX_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 112
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XgbipRWptefvmcVo/TpeAdwMpns53pex7vqqTxhUjT2CbQdHTsDE0ThXDmY0/OqbygHqLFmtDujn6g8!o7r33JoK4g3151HeTBrNpFBOfIBDKj9OISTMtRMTNsyDWC0igtSH6YQZqEwRkq5oCVRyms2r/bop
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: 7190
 by: olcott - Fri, 15 Apr 2022 00:17 UTC

On 4/14/2022 7:12 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/14/2022 3:54 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>>
>>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said that
>>>>>>>>>>> P(P) halts. Oh, there is a third (c) you are using poetic license, and
>>>>>>>>>>> simulating the input means something silly. It's literal nonsense to
>>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>>
>>>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>>>>>>
>>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>>>>>>> That's not rhetoric. You've been too clear about this attempt. You
>>>>>>>>> need to try a new ruse.
>>>>>>>>
>>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>>
>>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>>> pointers. They are neither halting nor non-halting -- they are just
>>>>>>> pointers.
>>>>>>>
>>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>>> non-halting" means,
>>>>>>
>>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>>> damned liars will say that I never mentioned any of this.
>>>>> Just use the right terms. H(P,P) has not input. The call has
>>>>> arguments. They are just pointers. Pointers are not halting nor are
>>>>> they non halting. Given that this mantra is the core of what you are
>>>>> now claiming, I would have thought you would want to avoid it being
>>>>> patentent nonsense.
>>>>>
>>>>>> The input to H is the only way that finite strings can be passed to a
>>>>>> "C" function and points to the finite string of the machine code of P.
>>>>> H has no input. Do you mean the two pointer arguments?
>>>>>
>>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>>> input (P,P) and finds that it would never reach its own final state in
>>>>>> an unlimited number of simulated steps.
>>>>>
>>>>> (P,P) is too vague. What needs to be simulated is the first pointer
>>>>> being called as a function with the second as it's argument. I.e. the
>>>>> call P(P) is what should be simulated.
>>>>
>>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>>> own final state proves that this input is not-halting.
>>>>
>>>> Adding all of the tedious details that you suggest does not change
>>>> this fact.
>>>
>>> If you add all the corrections, sorry, "tedious details", it contradicts
>>> what you've said in the past. With the errors left in place, the naive
>>> reader won't knowing exactly what's being said -- and I think that's
>>> deliberate.
>>>
>>> For example, why talk about simulation at all since simulations of
>>> computations halt or don't halt if and only if the computations do
>>> themselves? Well, it adds yet another puff of smoke to the mirrors
>>> you've got in there already like what that "its" refers to (since
>>> nothing here has a final state), or what non-halting pointers are.
>>> "The input to H(P,P)" should mean the two pointers, P and P. Simulating
>>> them should mean simulating the call P(P) and the simulation "not
>>> reaching its own final state" should mean that the simulation of P(P)
>>> does not halt. And that happens if, and only if, the call P(P) itself
>>> does not halt.
>>>
>>> I honestly have no idea if that is what you mean, but if it is, it's
>>> wrong because P(P) halts. You are probably just trying to cover that
>>> up.
>>
>> That a non input halts, converts the world to Fascism or opens a very
>> popular brothel is totally unrelated to the easily confirmed fact that
>> the input to H(P,P)* does not halt.
>
> The correct value of H(P,P) is determined by the halting status of what
> you call a non input:

LIAR LIAR PANTS ON FIRE

As long as the correctly simulated input to H(P,P) would never halt then
we know it is non-halting.

Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.
Anyone that disagrees with this is a liar by definition.

--
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) [ liar by definition ]

<P82dncRZ0YI6J8X_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: 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: Thu, 14 Apr 2022 19:21:58 -0500
Date: Thu, 14 Apr 2022 19:21:58 -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) [
liar by definition ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<7b81816c-4864-4357-917b-a111f9abb626n@googlegroups.com>
<I5KdnSVY8pdCG8r_nZ2dnUU7_8zNnZ2d@giganews.com>
<3f2e6908-8a31-4cd2-b6b5-d2bc155cd92cn@googlegroups.com>
<I5KdnSRY8perFcr_nZ2dnUU7_8xh4p2d@giganews.com>
<346bc4f2-37f6-4b50-88a2-0d0585a72456n@googlegroups.com>
<_rSdnZNXUoDvFsr_nZ2dnUU7_8xh4p2d@giganews.com>
<f9a2fa84-9b92-4a78-8080-642f84f60558n@googlegroups.com>
<36udnR0ZM4ihEMr_nZ2dnUU7_8xh4p2d@giganews.com>
<0473bee1-bd4b-4e09-9f29-f928f7b0e47fn@googlegroups.com>
<mdSdnSErnKmXDcr_nZ2dnUU7_8zNnZ2d@giganews.com>
<f70d6e89-5fe4-4e4c-b7a8-52efeba6e22cn@googlegroups.com>
<bs2dnbLYgLTrDMr_nZ2dnUU7_8zNnZ2d@giganews.com>
<e1a3f5df-93e6-4b02-823f-739eb49417f1n@googlegroups.com>
<v_-dnfRAdeowCcr_nZ2dnUU7_8xh4p2d@giganews.com>
<ca64aa02-662a-4cb4-b528-da2109066335n@googlegroups.com>
<ieidnfSoTfZdCsr_nZ2dnUU7_8zNnZ2d@giganews.com>
<7891db88-8b20-4fed-a88f-a2aeb51795e1n@googlegroups.com>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7891db88-8b20-4fed-a88f-a2aeb51795e1n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <P82dncRZ0YI6J8X_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 298
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-spBx2SAts2N59ggT2CPgyBP+j6NuhSxrbzaT9GEcU5x7QJMQnyVwfT/wbHyKDepYJJJ33sXkf1dwXqj!EFYO1v1RFhxoD0uWPj5CBTC5kw/yHicntOghq0HtpoQsNBpl1Gaz3C7fAd1jv/HejJvWQ4BWniuc
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: 20718
 by: olcott - Fri, 15 Apr 2022 00:21 UTC

On 4/14/2022 6:55 AM, Dennis Bush wrote:
> On Wednesday, April 13, 2022 at 11:40:55 PM UTC-4, olcott wrote:
>> On 4/13/2022 10:33 PM, Dennis Bush wrote:
>>> On Wednesday, April 13, 2022 at 11:27:49 PM UTC-4, olcott wrote:
>>>> On 4/13/2022 10:16 PM, Dennis Bush wrote:
>>>>> On Wednesday, April 13, 2022 at 11:14:05 PM UTC-4, olcott wrote:
>>>>>> On 4/13/2022 10:09 PM, Dennis Bush wrote:
>>>>>>> On Wednesday, April 13, 2022 at 11:08:02 PM UTC-4, olcott wrote:
>>>>>>>> On 4/13/2022 10:03 PM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, April 13, 2022 at 10:56:03 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/13/2022 9:50 PM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:48:25 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 4/13/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:34:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 4/13/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:28:54 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 4/13/2022 9:14 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:06:03 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/13/2022 6:45 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:35:34 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:25 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:23:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:17:52 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:15 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:09:11 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:59:47 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:56 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:53:05 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:13 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:06:02 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 7:49 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 8:06 AM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 8:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 6:55 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:05 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:18 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The truth is not determined by who does or does not agree with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something. But to find the truth of the matter you must first stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking literal nonsense. The arguments to H (what you call the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "input") are two pointers. What does simulating two pointers mean?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What you mean, I hope, is simulating calling the first pointer with the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> second as it's argument. That simulation, according to you, will halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (or "reach it's final state" in your flamboyant, sciencey, language).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It will halt because the direct call P(P) halts. Everything here halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (according to you). That's why H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply are ignoring the actual execution trace that conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulated input to H cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The traces that matter are the one of P(P) halting (you made the mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of posting it once), and the one of H(P,P) return false (you posted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as well). You a free to retract any of these at any time, but until you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, your H is wrong by your own supplied traces.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is never the case that the simulated input to H(P,P) ever reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Waffle. HP(P) halts so (P,P) == false is wrong. You can retract
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typo: "so H(P,P) == false is wrong"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these facts (since they come from you in the first place). Until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then, you've told us that your H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that the simulated input never reaches its [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine address, no waffle there merely an easily verified fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can verify a thousand more irrelevant facts. The facts that matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are already known: that P(P) halts and that H(P,P) == false. Are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presenting any verified facts that corrects this mistake? If so, just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say and I'll stop quoting it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The sequence of configurations specified by P(P) intuitively seems
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> like it must be identical to the correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P). It turns out that intuition is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So which fact are you retracting? That P(P) halts or that H(P,P) ==
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the correctly simulated input to H(P,P) cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this input then we know that it never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if everyone in the universe disagrees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you plan to keep posting the same sentence in an attempt to take
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the focus off the fact that H is obviously wrong?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then you must mean
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHOOP! WHOOP! WHOOP! Danger Will Robinson.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You should avoid trying to paraphrase other people. Your replies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> suggest you don't often understand the various points being put to you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so when you try to re-word them the results are usually bogus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a correctly simulated input that would never reaches its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state is still a computation that halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I meant what I said. If you are not sure that I meant, asking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> well-chosen questions about it is the way to go.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know [by definition] that a correctly simulated input that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state is not a halting computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the definition of halting is incorrect?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the correctly simulated input to H(P,P) does reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As a matter of fact it does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The simulated input to H(P,P) cannot possibly reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it keeps repeating [00000956] to [00000961] until aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000956](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095c](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000960](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above keeps repeating until aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096f](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000970](01) c3 ret // final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And when Hb simulates this input, it reaches a final state. Therefore H is wrong to report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A dishonest attempt at the strawman fallacy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bill up the street did not rob the liquor store I know this because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> other guy that I know named Bill was watching TV at the time of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> robbery.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words you have no rebuttal because you know that Hb(P,P) == true is correct and proves that H(P,P)==false is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>> Hb(P,P) is off topic because it proves nothing and you know that it
>>>>>>>>>>>>>>>>>>>>>>>>>> proves nothing and is just a disgusting attempt at a head game.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is not off topic because it directly contradicts your desired result. That you haven't explained why it's wrong is a confirmation of this.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> That is why I focus on the X proves Y
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (X) We can verify that the simulated input to H(P,P) fails to meet the
>>>>>>>>>>>>>>>>>>>>>>>>>> Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt whenever it enters
>>>>>>>>>>>>>>>>>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FALSE, because an incorrect simulation is not the same as a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (Y) When H(P,P) returns false it is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FALSE, as proved by Hb(P,P) returning true for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I CAN'T POSSIBLY BE WRONG UNLESS THERE IS AN ESSENTIAL MISTAKE IN X OR Y.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If the simulated input to H(P,P) fails to meet the definition of halting, then Ha3(N,5) also fails to meet that same definition of halting. So that along shows that your criteria is bogus.
>>>>>>>>>>>>>>>>>>>>>>>> I can see that you don't want this dialogue to continue.
>>>>>>>>>>>>>>>>>>>>>>>> I will not tolerate head games.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Translation:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> "I will not tolerate arguments that conclusively prove me wrong because I can't bear the though of having wasted the last 17 years".
>>>>>>>>>>>>>>>>>>>>>> You are trying to prove that Bill Smith is not guilty because Bill Jones
>>>>>>>>>>>>>>>>>>>>>> didn't do it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Another bad analogy. Further proof that you have no rebuttal.
>>>>>>>>>>>>>>>>>>>> That H(P,P)==false is correct is true by logical necessity.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, that Hb(P,P)==true is correct by logical necessity.
>>>>>>>>>>>>>>>>>> I will dumb it down for you: (Do not not believe in tautologies ?)
>>>>>>>>>>>>>>>>>> Because the input to H(P,P) is non-halting
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which is isn't as Hb demonstrates
>>>>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I see you didn't bother to explain why my explanation is wrong.
>>>>>>>>>>>>>> If an X <is a> Y and Dennis disagrees then Dennis is a liar.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Still no explanation.
>>>>>>>>>>>>>
>>>>>>>>>>>> It is a verified fact that the input to H(P,P) is non-halting and Dennis
>>>>>>>>>>>> denies this therefore Dennis is a liar. Is it fun being a liar?
>>>>>>>>>>>
>>>>>>>>>>> It is a verified fact that the input to H(P,P) is *halting* as follows:
>>>>>>>>>> Liar !
>>>>>>>>>
>>>>>>>>> This just shows everyone reading not only that you're wrong, but that you know it.
>>>>>>>> If an X is a Y and you deny it then you are a liar.
>>>>>>>> The simulated input to H(P,P) is non-halting and you know it.
>>>>>>>> Is it fun being a liar?
>>>>>>>
>>>>>>> You're really struggling with this aren't you?
>>>>>>>
>>>>>> I am not struggling with the fact that you are having fun being a liar.
>>>>>>
>>>>>> Unlike everyone else I have a direct measure of your competence, so you
>>>>>> can't fool me about what you don't understand.
>>>>>
>>>>> Then you should have no problem explaining EXACTLY why this is wrong:
>>>>>
>>>>>
>>>>> The simulated input does reach a final state when simulated by Hb.
>>>>>
>>>>> _P()
>>>>> [00000956](01) 55 push ebp
>>>>> [00000957](02) 8bec mov ebp,esp
>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>> [0000095c](01) 50 push eax // push P
>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [00000960](01) 51 push ecx // push P
>>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>>> //The above returns false
>>>>> [00000966](03) 83c408 add esp,+08
>>>>> [00000969](02) 85c0 test eax,eax
>>>>> [0000096b](02) 7402 jz 0000096f
>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>> [0000096f](01) 5d pop ebp
>>>>> [00000970](01) c3 ret // final state.
>>>>> // Hb reaches the final state of its input
>>>>>
>>>>> Hb and H are both simulating halt deciders and are given the same input so
>>>>> both are answering the exact same question but get different results,
>>>> As long as the correctly simulated input to H(P,P) would never halt then
>>>> we know it is non-halting.
>>>
>>> You just keep repeating with no explanation that H(P,P)==false is correct. I explain it detail why it's not.
>>>
>>> Hb demonstrates that the correctly simulated input to H(P,P) i.e. (P,P) DOES halt. So find an error:
>>>
>>> _P()
>>> [00000956](01) 55 push ebp
>>> [00000957](02) 8bec mov ebp,esp
>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>> [0000095c](01) 50 push eax // push P
>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>> [00000960](01) 51 push ecx // push P
>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>> //The above returns false
>>> [00000966](03) 83c408 add esp,+08
>>> [00000969](02) 85c0 test eax,eax
>>> [0000096b](02) 7402 jz 0000096f
>>> [0000096d](02) ebfe jmp 0000096d
>>> [0000096f](01) 5d pop ebp
>>> [00000970](01) c3 ret // final state.
>>> // Hb reaches the final state of its input
>>>
>> ONE OF THESE ASSUMPTIONS MUST BE INCORRECT* BECAUSE IT CONTRADICTS
>> LOGICAL NECESSITY (*It doesn't freaking matter which one).
>>> Hb and H are both simulating halt deciders
>>> and are given the same input so both are
>>> answering the exact same question but get
>>> different results, so one must be wrong. correct.
>> As long as the correctly simulated input to H(P,P) would never halt then
>> we know it is non-halting.
>
> Obviously, *if* the correctly simulated input to H(P,P) would never halt then we know it is non-halting. The problem is the correctly simulated input DOES halt.
>
> H makes an abort decision and leaves UTM mode to abort. Hb *never* leaves UTM mode and simulates the input to a final state.
>
> Therefore Hb(P,P)==true is correct, proving that H(P,P)==false is incorrect.


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

<c636K.743129$oF2.196553@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.neodome.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.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) [
liar by definition ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk> <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk> <P82dncVZ0YIPJMX_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <P82dncVZ0YIPJMX_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 144
Message-ID: <c636K.743129$oF2.196553@fx10.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: Thu, 14 Apr 2022 20:36:25 -0400
X-Received-Bytes: 8082
 by: Richard Damon - Fri, 15 Apr 2022 00:36 UTC

On 4/14/22 8:17 PM, olcott wrote:
> On 4/14/2022 7:12 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 3:54 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have
>>>>>>>>>>>> said that
>>>>>>>>>>>> P(P) halts.  Oh, there is a third (c) you are using poetic
>>>>>>>>>>>> license, and
>>>>>>>>>>>> simulating the input means something silly.  It's literal
>>>>>>>>>>>> nonsense to
>>>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>>>
>>>>>>>>>>> When mere rhetoric goes against easily verified facts
>>>>>>>>>>> rhetoric loses:
>>>>>>>>>>
>>>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P)
>>>>>>>>>> halts.
>>>>>>>>>> That's not rhetoric.  You've been too clear about this
>>>>>>>>>> attempt.  You
>>>>>>>>>> need to try a new ruse.
>>>>>>>>>
>>>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>>>
>>>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>>>> pointers.  They are neither halting nor non-halting -- they are
>>>>>>>> just
>>>>>>>> pointers.
>>>>>>>>
>>>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>>>> non-halting" means,
>>>>>>>
>>>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>>>> damned liars will say that I never mentioned any of this.
>>>>>> Just use the right terms.  H(P,P) has not input.  The call has
>>>>>> arguments.  They are just pointers.  Pointers are not halting nor are
>>>>>> they non halting.  Given that this mantra is the core of what you are
>>>>>> now claiming, I would have thought you would want to avoid it being
>>>>>> patentent nonsense.
>>>>>>
>>>>>>> The input to H is the only way that finite strings can be passed
>>>>>>> to a
>>>>>>> "C" function and points to the finite string of the machine code
>>>>>>> of P.
>>>>>> H has no input.  Do you mean the two pointer arguments?
>>>>>>
>>>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>>>> input (P,P) and finds that it would never reach its own final
>>>>>>> state in
>>>>>>> an unlimited number of simulated steps.
>>>>>>
>>>>>> (P,P) is too vague.  What needs to be simulated is the first pointer
>>>>>> being called as a function with the second as it's argument.  I.e.
>>>>>> the
>>>>>> call P(P) is what should be simulated.
>>>>>
>>>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>>>> own final state proves that this input is not-halting.
>>>>>
>>>>> Adding all of the tedious details that you suggest does not change
>>>>> this fact.
>>>>
>>>> If you add all the corrections, sorry, "tedious details", it
>>>> contradicts
>>>> what you've said in the past.  With the errors left in place, the naive
>>>> reader won't knowing exactly what's being said -- and I think that's
>>>> deliberate.
>>>>
>>>> For example, why talk about simulation at all since simulations of
>>>> computations halt or don't halt if and only if the computations do
>>>> themselves?  Well, it adds yet another puff of smoke to the mirrors
>>>> you've got in there already like what that "its" refers to (since
>>>> nothing here has a final state), or what non-halting pointers are.
>>>> "The input to H(P,P)" should mean the two pointers, P and P.
>>>> Simulating
>>>> them should mean simulating the call P(P) and the simulation "not
>>>> reaching its own final state" should mean that the simulation of P(P)
>>>> does not halt.  And that happens if, and only if, the call P(P) itself
>>>> does not halt.
>>>>
>>>> I honestly have no idea if that is what you mean, but if it is, it's
>>>> wrong because P(P) halts.  You are probably just trying to cover that
>>>> up.
>>>
>>> That a non input halts, converts the world to Fascism or opens a very
>>> popular brothel is totally unrelated to the easily confirmed fact that
>>> the input to H(P,P)* does not halt.
>>
>> The correct value of H(P,P) is determined by the halting status of what
>> you call a non input:
>
> LIAR LIAR PANTS ON FIRE
>
> As long as the correctly simulated input to H(P,P) would never halt then
> we know it is non-halting.
>
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
>

Except that it isn't true that the correctly simulated input to H(P,P)
would never halt, as YOU posted a correct simulation that showed that it
DOES Halt.

Thus YOUR claims that it would never halt are incorrect, and your
speading that falsehood make YOU the LIAR, by definition.

Sorry to hve to tell you that, but your logic just fails to be corrext,
and thus YOU are the one doomed to eternal fire because of your falsehoods.

You don't have the power or authority to change the rules of the game,
so by trying you have just condemned yourself to be disqualified to be
able to say anything acceptable about it.

You are just proving for eternity that you are just ignorant about
anything related to this topic, anything about Turing Machines,
Computation, Proofs, or even the basics of logic.

That is going to be your legacy, that Peter Olcott was just a lying kook
that didn't know enough to know that he didn't know about those things.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ liar by definition ]

<P636K.743130$oF2.734819@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeds.phibee-telecom.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.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) [
liar by definition ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ilrh7tr3.fsf@bsb.me.uk> <74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk> <op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk> <NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk> <N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk> <H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me> <X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me> <mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me> <V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk> <77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
<878rs7s92t.fsf@bsb.me.uk> <8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87r15zqkmq.fsf@bsb.me.uk> <P82dncpZ0YJgJcX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <P82dncpZ0YJgJcX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 34
Message-ID: <P636K.743130$oF2.734819@fx10.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: Thu, 14 Apr 2022 20:37:05 -0400
X-Received-Bytes: 3014
 by: Richard Damon - Fri, 15 Apr 2022 00:37 UTC

On 4/14/22 8:14 PM, olcott wrote:
> On 4/14/2022 7:02 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 3:28 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>> As long as the correctly simulated input to H(P,P) would never halt
>>>>> then we know it is non-halting.
>>>>
>>>> Readers beware!  Ask yourselves why PO does not say the simpler "never
>>>> halts", but instead says "/would/ never halt".  Why the implied
>>>> subjunctive mood?
>>>
>>> A simulating halt decider must correctly predict the future behavior
>>> of of its simulated input.
>>
>> But that's not what the implied subjunctive is about.  We know what it's
>> about because you've been clear in the past.  You need to justify the
>> wrong answer (false) for a halting computation.
>
> As long as the correctly simulated input to H(P,P) would never halt then
> we know it is non-halting.
>
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
>
>

WRONG. YOU ARE THE LIAR.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ liar by definition ]

<K736K.743131$oF2.678540@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!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!fx10.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) [
liar by definition ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<I5KdnSVY8pdCG8r_nZ2dnUU7_8zNnZ2d@giganews.com>
<3f2e6908-8a31-4cd2-b6b5-d2bc155cd92cn@googlegroups.com>
<I5KdnSRY8perFcr_nZ2dnUU7_8xh4p2d@giganews.com>
<346bc4f2-37f6-4b50-88a2-0d0585a72456n@googlegroups.com>
<_rSdnZNXUoDvFsr_nZ2dnUU7_8xh4p2d@giganews.com>
<f9a2fa84-9b92-4a78-8080-642f84f60558n@googlegroups.com>
<36udnR0ZM4ihEMr_nZ2dnUU7_8xh4p2d@giganews.com>
<0473bee1-bd4b-4e09-9f29-f928f7b0e47fn@googlegroups.com>
<mdSdnSErnKmXDcr_nZ2dnUU7_8zNnZ2d@giganews.com>
<f70d6e89-5fe4-4e4c-b7a8-52efeba6e22cn@googlegroups.com>
<bs2dnbLYgLTrDMr_nZ2dnUU7_8zNnZ2d@giganews.com>
<e1a3f5df-93e6-4b02-823f-739eb49417f1n@googlegroups.com>
<v_-dnfRAdeowCcr_nZ2dnUU7_8xh4p2d@giganews.com>
<ca64aa02-662a-4cb4-b528-da2109066335n@googlegroups.com>
<ieidnfSoTfZdCsr_nZ2dnUU7_8zNnZ2d@giganews.com>
<7891db88-8b20-4fed-a88f-a2aeb51795e1n@googlegroups.com>
<P82dncRZ0YI6J8X_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <P82dncRZ0YI6J8X_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 422
Message-ID: <K736K.743131$oF2.678540@fx10.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: Thu, 14 Apr 2022 20:38:04 -0400
X-Received-Bytes: 25011
 by: Richard Damon - Fri, 15 Apr 2022 00:38 UTC

On 4/14/22 8:21 PM, olcott wrote:
> On 4/14/2022 6:55 AM, Dennis Bush wrote:
>> On Wednesday, April 13, 2022 at 11:40:55 PM UTC-4, olcott wrote:
>>> On 4/13/2022 10:33 PM, Dennis Bush wrote:
>>>> On Wednesday, April 13, 2022 at 11:27:49 PM UTC-4, olcott wrote:
>>>>> On 4/13/2022 10:16 PM, Dennis Bush wrote:
>>>>>> On Wednesday, April 13, 2022 at 11:14:05 PM UTC-4, olcott wrote:
>>>>>>> On 4/13/2022 10:09 PM, Dennis Bush wrote:
>>>>>>>> On Wednesday, April 13, 2022 at 11:08:02 PM UTC-4, olcott wrote:
>>>>>>>>> On 4/13/2022 10:03 PM, Dennis Bush wrote:
>>>>>>>>>> On Wednesday, April 13, 2022 at 10:56:03 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 4/13/2022 9:50 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:48:25 PM UTC-4, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 4/13/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:34:37 PM UTC-4, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 4/13/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:28:54 PM UTC-4,
>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>> On 4/13/2022 9:14 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Wednesday, April 13, 2022 at 10:06:03 PM UTC-4,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/13/2022 6:45 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:35:34 PM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:25 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:23:46 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:17:52 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:15 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 11:09:11 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 10:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:59:47 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:56 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:53:05 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:13 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, April 12, 2022 at 10:06:02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 9:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 7:49 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/12/2022 8:06 AM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 8:02 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/11/2022 6:55 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:05 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:18 PM, Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The truth is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by who does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not agree with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something. But to find the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth of the matter you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must first stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking literal nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The arguments to H (what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you call the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "input") are two pointers.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What does simulating two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointers mean?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What you mean, I hope, is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating calling the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first pointer with the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> second as it's argument.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That simulation, according
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, will halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (or "reach it's final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state" in your flamboyant,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sciencey, language).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It will halt because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct call P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Everything here halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (according to you). That's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> why H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply are ignoring the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual execution trace that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The traces that matter are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the one of P(P) halting (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> made the mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of posting it once), and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one of H(P,P) return false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you posted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as well). You a free to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract any of these at any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time, but until you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do, your H is wrong by your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own supplied traces.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is never the case that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Waffle. HP(P) halts so (P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> == false is wrong. You can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> retract
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typo: "so H(P,P) == false is wrong"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these facts (since they come
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from you in the first place).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then, you've told us that your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine address, no waffle
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there merely an easily verified
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can verify a thousand more
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant facts. The facts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are already known: that P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts and that H(P,P) == false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presenting any verified facts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that corrects this mistake? If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so, just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say and I'll stop quoting it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by P(P) intuitively seems
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> like it must be identical to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P). It turns out that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intuition is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So which fact are you retracting?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That P(P) halts or that H(P,P) ==
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then we know that it never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if everyone in the universe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you plan to keep posting the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sentence in an attempt to take
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the focus off the fact that H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obviously wrong?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then you must mean
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHOOP! WHOOP! WHOOP! Danger Will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Robinson.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You should avoid trying to paraphrase
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other people. Your replies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> suggest you don't often understand the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various points being put to you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so when you try to re-word them the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> results are usually bogus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a correctly simulated input that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reaches its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state is still a computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I meant what I said. If you are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure that I meant, asking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> well-chosen questions about it is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way to go.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know [by definition] that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a halting computation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting is incorrect?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you saying that the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to H(P,P) does reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As a matter of fact it does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The simulated input to H(P,P) cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it keeps repeating [00000956] to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961] until aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000956](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095c](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000960](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000961](05) e8c0feffff call 00000826
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above keeps repeating until aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000096f](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00000970](01) c3 ret // final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00000970]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And when Hb simulates this input, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches a final state. Therefore H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong to report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A dishonest attempt at the strawman fallacy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bill up the street did not rob the liquor
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> store I know this because the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other guy that I know named Bill was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> watching TV at the time of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> robbery.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words you have no rebuttal
>>>>>>>>>>>>>>>>>>>>>>>>>>>> because you know that Hb(P,P) == true is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and proves that H(P,P)==false is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Hb(P,P) is off topic because it proves
>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing and you know that it
>>>>>>>>>>>>>>>>>>>>>>>>>>> proves nothing and is just a disgusting
>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt at a head game.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is not off topic because it directly
>>>>>>>>>>>>>>>>>>>>>>>>>> contradicts your desired result. That you
>>>>>>>>>>>>>>>>>>>>>>>>>> haven't explained why it's wrong is a
>>>>>>>>>>>>>>>>>>>>>>>>>> confirmation of this.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That is why I focus on the X proves Y
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (X) We can verify that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) fails to meet the
>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters
>>>>>>>>>>>>>>>>>>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FALSE, because an incorrect simulation is not
>>>>>>>>>>>>>>>>>>>>>>>>>> the same as a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (Y) When H(P,P) returns false it is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FALSE, as proved by Hb(P,P) returning true for
>>>>>>>>>>>>>>>>>>>>>>>>>> the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I CAN'T POSSIBLY BE WRONG UNLESS THERE IS AN
>>>>>>>>>>>>>>>>>>>>>>>>>>> ESSENTIAL MISTAKE IN X OR Y.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If the simulated input to H(P,P) fails to meet
>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of halting, then Ha3(N,5) also
>>>>>>>>>>>>>>>>>>>>>>>>>> fails to meet that same definition of halting.
>>>>>>>>>>>>>>>>>>>>>>>>>> So that along shows that your criteria is bogus.
>>>>>>>>>>>>>>>>>>>>>>>>> I can see that you don't want this dialogue to
>>>>>>>>>>>>>>>>>>>>>>>>> continue.
>>>>>>>>>>>>>>>>>>>>>>>>> I will not tolerate head games.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Translation:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "I will not tolerate arguments that conclusively
>>>>>>>>>>>>>>>>>>>>>>>> prove me wrong because I can't bear the though
>>>>>>>>>>>>>>>>>>>>>>>> of having wasted the last 17 years".
>>>>>>>>>>>>>>>>>>>>>>> You are trying to prove that Bill Smith is not
>>>>>>>>>>>>>>>>>>>>>>> guilty because Bill Jones
>>>>>>>>>>>>>>>>>>>>>>> didn't do it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Another bad analogy. Further proof that you have
>>>>>>>>>>>>>>>>>>>>>> no rebuttal.
>>>>>>>>>>>>>>>>>>>>> That H(P,P)==false is correct is true by logical
>>>>>>>>>>>>>>>>>>>>> necessity.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, that Hb(P,P)==true is correct by logical necessity.
>>>>>>>>>>>>>>>>>>> I will dumb it down for you: (Do not not believe in
>>>>>>>>>>>>>>>>>>> tautologies ?)
>>>>>>>>>>>>>>>>>>> Because the input to H(P,P) is non-halting
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Which is isn't as Hb demonstrates
>>>>>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I see you didn't bother to explain why my explanation is
>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>> If an X <is a> Y and Dennis disagrees then Dennis is a liar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Still no explanation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> It is a verified fact that the input to H(P,P) is
>>>>>>>>>>>>> non-halting and Dennis
>>>>>>>>>>>>> denies this therefore Dennis is a liar. Is it fun being a
>>>>>>>>>>>>> liar?
>>>>>>>>>>>>
>>>>>>>>>>>> It is a verified fact that the input to H(P,P) is *halting*
>>>>>>>>>>>> as follows:
>>>>>>>>>>> Liar !
>>>>>>>>>>
>>>>>>>>>> This just shows everyone reading not only that you're wrong,
>>>>>>>>>> but that you know it.
>>>>>>>>> If an X is a Y and you deny it then you are a liar.
>>>>>>>>> The simulated input to H(P,P) is non-halting and you know it.
>>>>>>>>> Is it fun being a liar?
>>>>>>>>
>>>>>>>> You're really struggling with this aren't you?
>>>>>>>>
>>>>>>> I am not struggling with the fact that you are having fun being a
>>>>>>> liar.
>>>>>>>
>>>>>>> Unlike everyone else I have a direct measure of your competence,
>>>>>>> so you
>>>>>>> can't fool me about what you don't understand.
>>>>>>
>>>>>> Then you should have no problem explaining EXACTLY why this is wrong:
>>>>>>
>>>>>>
>>>>>> The simulated input does reach a final state when simulated by Hb.
>>>>>>
>>>>>> _P()
>>>>>> [00000956](01) 55 push ebp
>>>>>> [00000957](02) 8bec mov ebp,esp
>>>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>>>> [0000095c](01) 50 push eax // push P
>>>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00000960](01) 51 push ecx // push P
>>>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>>>> //The above returns false
>>>>>> [00000966](03) 83c408 add esp,+08
>>>>>> [00000969](02) 85c0 test eax,eax
>>>>>> [0000096b](02) 7402 jz 0000096f
>>>>>> [0000096d](02) ebfe jmp 0000096d
>>>>>> [0000096f](01) 5d pop ebp
>>>>>> [00000970](01) c3 ret // final state.
>>>>>> // Hb reaches the final state of its input
>>>>>>
>>>>>> Hb and H are both simulating halt deciders and are given the same
>>>>>> input so
>>>>>> both are answering the exact same question but get different results,
>>>>> As long as the correctly simulated input to H(P,P) would never halt
>>>>> then
>>>>> we know it is non-halting.
>>>>
>>>> You just keep repeating with no explanation that H(P,P)==false is
>>>> correct. I explain it detail why it's not.
>>>>
>>>> Hb demonstrates that the correctly simulated input to H(P,P) i.e.
>>>> (P,P) DOES halt. So find an error:
>>>>
>>>> _P()
>>>> [00000956](01) 55 push ebp
>>>> [00000957](02) 8bec mov ebp,esp
>>>> [00000959](03) 8b4508 mov eax,[ebp+08]
>>>> [0000095c](01) 50 push eax // push P
>>>> [0000095d](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000960](01) 51 push ecx // push P
>>>> [00000961](05) e8c0feffff call 00000826 // call H(P,P)
>>>> //The above returns false
>>>> [00000966](03) 83c408 add esp,+08
>>>> [00000969](02) 85c0 test eax,eax
>>>> [0000096b](02) 7402 jz 0000096f
>>>> [0000096d](02) ebfe jmp 0000096d
>>>> [0000096f](01) 5d pop ebp
>>>> [00000970](01) c3 ret // final state.
>>>> // Hb reaches the final state of its input
>>>>
>>> ONE OF THESE ASSUMPTIONS MUST BE INCORRECT* BECAUSE IT CONTRADICTS
>>> LOGICAL NECESSITY (*It doesn't freaking matter which one).
>>>> Hb and H are both simulating halt deciders
>>>> and are given the same input so both are
>>>> answering the exact same question but get
>>>> different results, so one must be wrong. correct.
>>> As long as the correctly simulated input to H(P,P) would never halt then
>>> we know it is non-halting.
>>
>> Obviously, *if* the correctly simulated input to H(P,P) would never
>> halt then we know it is non-halting.  The problem is the correctly
>> simulated input DOES halt.
>>
>> H makes an abort decision and leaves UTM mode to abort. Hb *never*
>> leaves UTM mode and simulates the input to a final state.
>>
>> Therefore Hb(P,P)==true is correct, proving that H(P,P)==false is
>> incorrect.
>
>
> As long as the correctly simulated input to H(P,P) would never halt then
> we know it is non-halting.
>
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
>
>


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

<vcidnT01o4J7IsX_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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: Thu, 14 Apr 2022 19:44:21 -0500
Date: Thu, 14 Apr 2022 19:44:21 -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) [
Why lie ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk> <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87lew7qk6k.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <vcidnT01o4J7IsX_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 118
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jFXTbHpO1QbvrRkyPqoVLykQtZpiRmMAS/7yWWATQpVXUe/N153eVPcXJ6KTw0moFqD9imXhbgH1JBR!bS+Zo2n4q7Ae+sda3N4tRDJc2TJuQsIrvySXZuDZALPOZDNP3+2xm+yIMVR7IBM5RZuMC7MDWYAM
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: 6990
 by: olcott - Fri, 15 Apr 2022 00:44 UTC

On 4/14/2022 7:12 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/14/2022 3:54 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>>
>>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said that
>>>>>>>>>>> P(P) halts. Oh, there is a third (c) you are using poetic license, and
>>>>>>>>>>> simulating the input means something silly. It's literal nonsense to
>>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>>
>>>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>>>>>>
>>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>>>>>>> That's not rhetoric. You've been too clear about this attempt. You
>>>>>>>>> need to try a new ruse.
>>>>>>>>
>>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>>
>>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>>> pointers. They are neither halting nor non-halting -- they are just
>>>>>>> pointers.
>>>>>>>
>>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>>> non-halting" means,
>>>>>>
>>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>>> damned liars will say that I never mentioned any of this.
>>>>> Just use the right terms. H(P,P) has not input. The call has
>>>>> arguments. They are just pointers. Pointers are not halting nor are
>>>>> they non halting. Given that this mantra is the core of what you are
>>>>> now claiming, I would have thought you would want to avoid it being
>>>>> patentent nonsense.
>>>>>
>>>>>> The input to H is the only way that finite strings can be passed to a
>>>>>> "C" function and points to the finite string of the machine code of P.
>>>>> H has no input. Do you mean the two pointer arguments?
>>>>>
>>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>>> input (P,P) and finds that it would never reach its own final state in
>>>>>> an unlimited number of simulated steps.
>>>>>
>>>>> (P,P) is too vague. What needs to be simulated is the first pointer
>>>>> being called as a function with the second as it's argument. I.e. the
>>>>> call P(P) is what should be simulated.
>>>>
>>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>>> own final state proves that this input is not-halting.
>>>>
>>>> Adding all of the tedious details that you suggest does not change
>>>> this fact.
>>>
>>> If you add all the corrections, sorry, "tedious details", it contradicts
>>> what you've said in the past. With the errors left in place, the naive
>>> reader won't knowing exactly what's being said -- and I think that's
>>> deliberate.
>>>
>>> For example, why talk about simulation at all since simulations of
>>> computations halt or don't halt if and only if the computations do
>>> themselves? Well, it adds yet another puff of smoke to the mirrors
>>> you've got in there already like what that "its" refers to (since
>>> nothing here has a final state), or what non-halting pointers are.
>>> "The input to H(P,P)" should mean the two pointers, P and P. Simulating
>>> them should mean simulating the call P(P) and the simulation "not
>>> reaching its own final state" should mean that the simulation of P(P)
>>> does not halt. And that happens if, and only if, the call P(P) itself
>>> does not halt.
>>>
>>> I honestly have no idea if that is what you mean, but if it is, it's
>>> wrong because P(P) halts. You are probably just trying to cover that
>>> up.
>>
>> That a non input halts, converts the world to Fascism or opens a very
>> popular brothel is totally unrelated to the easily confirmed fact that
>> the input to H(P,P)* does not halt.
>
> The correct value of H(P,P) is determined by the halting status of what
> you call a non input:

LIAR LIAR PANTS ON FIRE

You know damn well that a halt decider must compute the mapping
FROM ITS INPUTS
FROM ITS INPUTS
FROM ITS INPUTS

Any damn thing that computes the mapping from a non-input
IS WRONG BY DEFINITION
IS WRONG BY DEFINITION
IS WRONG BY DEFINITION

Why lie ?

--
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) [ Why lie ? ]

<t3afhl$fov$1@gioia.aioe.org>

 copy mid

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

 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) [
Why lie ? ]
Date: Fri, 15 Apr 2022 02:51:31 +0200
Organization: Aioe.org NNTP Server
Message-ID: <t3afhl$fov$1@gioia.aioe.org>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk> <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk> <vcidnT01o4J7IsX_nZ2dnUU7_83NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="16159"; 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
Content-Language: fr
X-Notice: Filtered by postfilter v. 0.9.2
 by: Python - Fri, 15 Apr 2022 00:51 UTC

Mortal sinner Peter Olcott wrote:
....
> Why lie ?

You could tell us, as you are the liar down here.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ Why lie ? ]

<QK36K.92369$n41.54176@fx35.iad>

 copy mid

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

 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!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.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) [
Why lie ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87czhm1m9c.fsf@bsb.me.uk> <IZ-dnX8Uh_2iBMj_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk> <EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk> <acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk> <B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk> <9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk> <hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk> <yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk> <apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk> <q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk> <YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk> <vcidnT01o4J7IsX_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <vcidnT01o4J7IsX_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 148
Message-ID: <QK36K.92369$n41.54176@fx35.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: Thu, 14 Apr 2022 21:19:45 -0400
X-Received-Bytes: 7794
X-Original-Bytes: 7661
 by: Richard Damon - Fri, 15 Apr 2022 01:19 UTC

On 4/14/22 8:44 PM, olcott wrote:
> On 4/14/2022 7:12 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 3:54 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have
>>>>>>>>>>>> said that
>>>>>>>>>>>> P(P) halts.  Oh, there is a third (c) you are using poetic
>>>>>>>>>>>> license, and
>>>>>>>>>>>> simulating the input means something silly.  It's literal
>>>>>>>>>>>> nonsense to
>>>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>>>
>>>>>>>>>>> When mere rhetoric goes against easily verified facts
>>>>>>>>>>> rhetoric loses:
>>>>>>>>>>
>>>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P)
>>>>>>>>>> halts.
>>>>>>>>>> That's not rhetoric.  You've been too clear about this
>>>>>>>>>> attempt.  You
>>>>>>>>>> need to try a new ruse.
>>>>>>>>>
>>>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>>>
>>>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>>>> pointers.  They are neither halting nor non-halting -- they are
>>>>>>>> just
>>>>>>>> pointers.
>>>>>>>>
>>>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>>>> non-halting" means,
>>>>>>>
>>>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>>>> damned liars will say that I never mentioned any of this.
>>>>>> Just use the right terms.  H(P,P) has not input.  The call has
>>>>>> arguments.  They are just pointers.  Pointers are not halting nor are
>>>>>> they non halting.  Given that this mantra is the core of what you are
>>>>>> now claiming, I would have thought you would want to avoid it being
>>>>>> patentent nonsense.
>>>>>>
>>>>>>> The input to H is the only way that finite strings can be passed
>>>>>>> to a
>>>>>>> "C" function and points to the finite string of the machine code
>>>>>>> of P.
>>>>>> H has no input.  Do you mean the two pointer arguments?
>>>>>>
>>>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>>>> input (P,P) and finds that it would never reach its own final
>>>>>>> state in
>>>>>>> an unlimited number of simulated steps.
>>>>>>
>>>>>> (P,P) is too vague.  What needs to be simulated is the first pointer
>>>>>> being called as a function with the second as it's argument.  I.e.
>>>>>> the
>>>>>> call P(P) is what should be simulated.
>>>>>
>>>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>>>> own final state proves that this input is not-halting.
>>>>>
>>>>> Adding all of the tedious details that you suggest does not change
>>>>> this fact.
>>>>
>>>> If you add all the corrections, sorry, "tedious details", it
>>>> contradicts
>>>> what you've said in the past.  With the errors left in place, the naive
>>>> reader won't knowing exactly what's being said -- and I think that's
>>>> deliberate.
>>>>
>>>> For example, why talk about simulation at all since simulations of
>>>> computations halt or don't halt if and only if the computations do
>>>> themselves?  Well, it adds yet another puff of smoke to the mirrors
>>>> you've got in there already like what that "its" refers to (since
>>>> nothing here has a final state), or what non-halting pointers are.
>>>> "The input to H(P,P)" should mean the two pointers, P and P.
>>>> Simulating
>>>> them should mean simulating the call P(P) and the simulation "not
>>>> reaching its own final state" should mean that the simulation of P(P)
>>>> does not halt.  And that happens if, and only if, the call P(P) itself
>>>> does not halt.
>>>>
>>>> I honestly have no idea if that is what you mean, but if it is, it's
>>>> wrong because P(P) halts.  You are probably just trying to cover that
>>>> up.
>>>
>>> That a non input halts, converts the world to Fascism or opens a very
>>> popular brothel is totally unrelated to the easily confirmed fact that
>>> the input to H(P,P)* does not halt.
>>
>> The correct value of H(P,P) is determined by the halting status of what
>> you call a non input:
>
>
> LIAR LIAR PANTS ON FIRE
>
> You know damn well that a halt decider must compute the mapping
> FROM ITS INPUTS
> FROM ITS INPUTS
> FROM ITS INPUTS

Right, and the input to the Turing Machine H is <H^> <H^> and the
DEFINITION of the behavior of that input is H^ applied to <H^>, so if
the program H is supposed to be an equivalent of that, H(P,P) needs to
use the input P,P to compute the behavior of the program P(P).

>
> Any damn thing that computes the mapping from a non-input
> IS WRONG BY DEFINITION
> IS WRONG BY DEFINITION
> IS WRONG BY DEFINITION
>
> Why lie ?
>

Yes, Why do YOU LIE. when the behavior I ask for is from the DEFINITION
of the problem, but yours isn't. I AM asking fro a mapping of the input.

<H^> <H^> IS the input, and that is what H needs to compute its answer from.

Just like P,P is the input, and that is what H() needs to compute its
answer from.

Note, the fact that you can't actually compute the Halting behavior of
the input with an actual computation doesn't mean the problem is 'wrong'
or misdefined, it means this problem is just not a computable function.

Non-Computable functions are perfectly ok to exists, dispite your
protestations.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ Why lie ? ]

<87fsmer2y3.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ Why lie ? ]
Date: Fri, 15 Apr 2022 12:39:00 +0100
Organization: A noiseless patient Spider
Lines: 154
Message-ID: <87fsmer2y3.fsf@bsb.me.uk>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk>
<EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk>
<acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk>
<B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk>
<9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk>
<hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk>
<yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk>
<apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk>
<q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk>
<YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk>
<vcidnT01o4J7IsX_nZ2dnUU7_83NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="f8b67a7155e27a25649c34539ea91f50";
logging-data="17089"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+Z+r4YWR8/l1tm3V+ND6minv19LF+gXIQ="
Cancel-Lock: sha1:6+z9iGdxcanCyvwxGxYy4CSeofI=
sha1:MQ2BK3NEURup0eEguCMlAEmBw4M=
X-BSB-Auth: 1.4134a978761bf12c745c.20220415123900BST.87fsmer2y3.fsf@bsb.me.uk
 by: Ben - Fri, 15 Apr 2022 11:39 UTC

olcott <NoOne@NoWhere.com> writes:

> On 4/14/2022 7:12 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 3:54 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have said that
>>>>>>>>>>>> P(P) halts. Oh, there is a third (c) you are using poetic license, and
>>>>>>>>>>>> simulating the input means something silly. It's literal nonsense to
>>>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>>>
>>>>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric loses:
>>>>>>>>>>
>>>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P) halts.
>>>>>>>>>> That's not rhetoric. You've been too clear about this attempt. You
>>>>>>>>>> need to try a new ruse.
>>>>>>>>>
>>>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>>>
>>>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>>>> pointers. They are neither halting nor non-halting -- they are just
>>>>>>>> pointers.
>>>>>>>>
>>>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>>>> non-halting" means,
>>>>>>>
>>>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>>>> damned liars will say that I never mentioned any of this.
>>>>>> Just use the right terms. H(P,P) has not input. The call has
>>>>>> arguments. They are just pointers. Pointers are not halting nor are
>>>>>> they non halting. Given that this mantra is the core of what you are
>>>>>> now claiming, I would have thought you would want to avoid it being
>>>>>> patentent nonsense.
>>>>>>
>>>>>>> The input to H is the only way that finite strings can be passed to a
>>>>>>> "C" function and points to the finite string of the machine code of P.
>>>>>> H has no input. Do you mean the two pointer arguments?
>>>>>>
>>>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>>>> input (P,P) and finds that it would never reach its own final state in
>>>>>>> an unlimited number of simulated steps.
>>>>>>
>>>>>> (P,P) is too vague. What needs to be simulated is the first pointer
>>>>>> being called as a function with the second as it's argument. I.e. the
>>>>>> call P(P) is what should be simulated.
>>>>>
>>>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>>>> own final state proves that this input is not-halting.
>>>>>
>>>>> Adding all of the tedious details that you suggest does not change
>>>>> this fact.
>>>>
>>>> If you add all the corrections, sorry, "tedious details", it contradicts
>>>> what you've said in the past. With the errors left in place, the naive
>>>> reader won't knowing exactly what's being said -- and I think that's
>>>> deliberate.
>>>>
>>>> For example, why talk about simulation at all since simulations of
>>>> computations halt or don't halt if and only if the computations do
>>>> themselves? Well, it adds yet another puff of smoke to the mirrors
>>>> you've got in there already like what that "its" refers to (since
>>>> nothing here has a final state), or what non-halting pointers are.
>>>> "The input to H(P,P)" should mean the two pointers, P and P. Simulating
>>>> them should mean simulating the call P(P) and the simulation "not
>>>> reaching its own final state" should mean that the simulation of P(P)
>>>> does not halt. And that happens if, and only if, the call P(P) itself
>>>> does not halt.
>>>>
>>>> I honestly have no idea if that is what you mean, but if it is, it's
>>>> wrong because P(P) halts. You are probably just trying to cover that
>>>> up.
>>>
>>> That a non input halts, converts the world to Fascism or opens a very
>>> popular brothel is totally unrelated to the easily confirmed fact that
>>> the input to H(P,P)* does not halt.
>>
>> The correct value of H(P,P) is determined by the halting status of what
>> you call a non input:
>
> LIAR LIAR PANTS ON FIRE

If this is one of the things you might say to that fictional room of
academics you imagine talking to, put me down for a front row seat!

> You know damn well that a halt decider must compute the mapping
> FROM ITS INPUTS

From its arguments.

> Any damn thing that computes the mapping from a non-input
> IS WRONG BY DEFINITION

I tried to help you with this, but you got stuck at the very start.

Anyway, you don't get to say what the correct answer is. You started
this massive waste of time by deciding, decades ago, to take up an
/existing/ problem. What your H has to return, for any given arguments,
is not up for debate. You can say you can't meet the specification
because it's in some way crazy -- that /is/ up to you (though you won't
find many takers) -- but you still can't meet the specification:

// H returns true if, and only if, the function call x(y) always
// returns (or halts if you prefer) no matter where it is called from.
// H returns false in all other cases.

typedef int (*ptr)();
int H(ptr x, ptr y);

Stamp your feet and shout that x(y) is a "non-input" all you like, but
this is the function you can't write[1].

Actually you can't write a function like that which decides /any/
non-trivial property of the function x. Can you write a function that
decides if there is some y for which x(y) == 42? No you can't. Can you
write a function that decides if x(0) == 0? No you can't.

And the list includes many practical and interesting problems such as
deciding if a context-free grammar is ambiguous or not.

> IS WRONG BY DEFINITION
> IS WRONG BY DEFINITION
>
> Why lie ?

How often have you got burned by this? I have never lied to you but
many times when you have accused me of lying, or playing head games, or,
on one occasion, of being mad, it's turned out that you just didn't know
what you were talking about. The last time was fixed only after I told
you, repeatedly, to read page 8 of Mendelson. On that occasion, you
didn't know what a sequence was just a function.

[1] Without tricks like H(x,y) returning different results when called
in different places in a program.

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ liar by definition ]

<87a6cmr2ii.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ liar by definition ]
Date: Fri, 15 Apr 2022 12:48:21 +0100
Organization: A noiseless patient Spider
Lines: 30
Message-ID: <87a6cmr2ii.fsf@bsb.me.uk>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87sfqhzu5h.fsf@bsb.me.uk>
<EYSdnbbaVLzwvsv_nZ2dnUU7_83NnZ2d@giganews.com>
<87wnftycf4.fsf@bsb.me.uk>
<acWdna9QAMDTs8v_nZ2dnUU7_81g4p2d@giganews.com>
<87a6cpyah6.fsf@bsb.me.uk>
<B6-dnWRCiaTipsv_nZ2dnUU7_81g4p2d@giganews.com>
<87bkx5vvi5.fsf@bsb.me.uk>
<9-mdnVlBfvzRbsv_nZ2dnUU7_8xh4p2d@giganews.com>
<87tuawvko7.fsf@bsb.me.uk>
<hfGdnW1c_aTTssr_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wnfstwnm.fsf@bsb.me.uk>
<yvSdnTV1yaEt8cr_nZ2dnUU7_83NnZ2d@giganews.com>
<87k0brspnx.fsf@bsb.me.uk>
<apCdnQvgYZorqMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee1zsjne.fsf@bsb.me.uk>
<q76dnVaeIav7y8X_nZ2dnUU7_83NnZ2d@giganews.com>
<8735ifs7vo.fsf@bsb.me.uk>
<YrGdnXX-0dGzAMX_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lew7qk6k.fsf@bsb.me.uk>
<P82dncVZ0YIPJMX_nZ2dnUU7_8xh4p2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="f8b67a7155e27a25649c34539ea91f50";
logging-data="17089"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19AO82ZkQqZaR3xfn9MBAsAOYGB9G9Zl5g="
Cancel-Lock: sha1:cvjRQqi0M5iMvh1E6FeJ4+45yaE=
sha1:trWB54XZ3W5tQoY9OiBNB5kBfFU=
X-BSB-Auth: 1.4eeaec7bba345c6c921a.20220415124821BST.87a6cmr2ii.fsf@bsb.me.uk
 by: Ben - Fri, 15 Apr 2022 11:48 UTC

olcott <NoOne@NoWhere.com> writes:

> On 4/14/2022 7:12 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:

>>> That a non input halts, converts the world to Fascism or opens a very
>>> popular brothel is totally unrelated to the easily confirmed fact that
>>> the input to H(P,P)* does not halt.
>>
>> The correct value of H(P,P) is determined by the halting status of what
>> you call a non input:
>
> LIAR LIAR PANTS ON FIRE

No. The correct value of H(P,P) is not for you to choose.

> As long as the correctly simulated input to H(P,P) would never halt
> then we know it is non-halting.
>
> Anyone that disagrees with this is a liar by definition.

As long as it's correctly stated, I would agree with it.

> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.
> Anyone that disagrees with this is a liar by definition.

--
Ben.

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

<73f32808-6d8b-4ab3-9eac-74c4d7634c26n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:3e3:b0:444:3f84:d230 with SMTP id cf3-20020a05621403e300b004443f84d230mr17241505qvb.4.1650026048900;
Fri, 15 Apr 2022 05:34:08 -0700 (PDT)
X-Received: by 2002:a25:b984:0:b0:629:6b2a:8328 with SMTP id
r4-20020a25b984000000b006296b2a8328mr5531773ybg.112.1650026048672; Fri, 15
Apr 2022 05:34:08 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Fri, 15 Apr 2022 05:34:08 -0700 (PDT)
In-Reply-To: <8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:43c:376c:16cb:75c4;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:43c:376c:16cb:75c4
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee268n4f.fsf@bsb.me.uk> <8qOdna7OrqepBsz_nZ2dnUU7_83NnZ2d@giganews.com>
<87ilrh7tr3.fsf@bsb.me.uk> <74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk> <op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk> <NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk> <N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk> <H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me> <X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me> <mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me> <V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk> <77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
<878rs7s92t.fsf@bsb.me.uk> <8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <73f32808-6d8b-4ab3-9eac-74c4d7634c26n@googlegroups.com>
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [
key missing piece in dialogue ][ back door ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Fri, 15 Apr 2022 12:34:08 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 38
 by: Malcolm McLean - Fri, 15 Apr 2022 12:34 UTC

On Thursday, 14 April 2022 at 21:42:05 UTC+1, olcott wrote:
> On 4/14/2022 3:28 PM, Ben wrote:
> > olcott <No...@NoWhere.com> writes:
> >> As long as the correctly simulated input to H(P,P) would never halt
> >> then we know it is non-halting.
> >
> > Readers beware! Ask yourselves why PO does not say the simpler "never
> > halts", but instead says "/would/ never halt". Why the implied
> > subjunctive mood?
> A simulating halt decider must correctly predict the future behavior of
> of its simulated input. Many of my readers get confused and believe that
> an aborted simulation means that the simulated input has halted.
>
> To an academic audience of computer scientists I would simply say that
> the behavior of the simulated input to H(P,P) conclusively proves that
> it is non-halting.
>
You have set up a confusing system, because a simulator is simulating
a simulator. Eventually one of the simulators decides that the system
of simulators simulating simultators will go on forever, and halts.
However it is wrong to do so, because the simulator it is simultating has
the same logic, and will make the same decision if it is allowed to run
for longer.
In the game pass the parcel, the children pass the parcel until the music
stops. What happens if we put the music on an endless loop?
Of course what happens is that eventually one child decides that this
will go on forever if he doesn't stop, and he aborts the game somehow,
for example by opening the parcel anyway. So, naively, you could say
"the game would have gone forever had that child not put a stop to it".
But in fact all the children have some tolerance level. No game of pass
the parcel will go on forever. Eventually even the most patient child will
decide he cannot continue to pass the parcel.
Now in your system, if one of the simulations didn't abort, then the
abort would be correct. But all the simulations run the same simulator.
If the simulators don't abort, then that is incorrect, becaue now they
really do run forever. There's no correct behaviour. Just we can't all
tell our children "never be the first to give up, because someone else
will always give up before you". That might be sound advice to a
subset of children, but not to all the children in the group.

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

<874k2uquqy.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof --- Version(11) [ key missing piece in dialogue ][ back door ]
Date: Fri, 15 Apr 2022 15:36:05 +0100
Organization: A noiseless patient Spider
Lines: 32
Message-ID: <874k2uquqy.fsf@bsb.me.uk>
References: <v6idnaCJifSVTtT_nZ2dnUU7_8zNnZ2d@giganews.com>
<74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com>
<87mtgt541v.fsf@bsb.me.uk>
<op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com>
<8735ik63ip.fsf@bsb.me.uk>
<NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ee244h7c.fsf@bsb.me.uk>
<N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com>
<87lewb2n1l.fsf@bsb.me.uk>
<H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com>
<t32id1$qma$1@dont-email.me>
<X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com>
<t3832d$dpk$1@dont-email.me>
<mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com>
<t3861c$tbc$1@dont-email.me>
<V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d7ru6vm.fsf@bsb.me.uk>
<77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com>
<878rs7s92t.fsf@bsb.me.uk>
<8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
<73f32808-6d8b-4ab3-9eac-74c4d7634c26n@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="f8b67a7155e27a25649c34539ea91f50";
logging-data="26712"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+4FTq7xh80/X03EfPUE7BA/kzG1I9vVr4="
Cancel-Lock: sha1:E/y+mDCp1JjNz6tRDST0rZfU/4A=
sha1:KwhnFVkXlSdMQMuA6pKX2JLGuzA=
X-BSB-Auth: 1.adb5070608a44c2eb5cc.20220415153605BST.874k2uquqy.fsf@bsb.me.uk
 by: Ben - Fri, 15 Apr 2022 14:36 UTC

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Thursday, 14 April 2022 at 21:42:05 UTC+1, olcott wrote:
>> On 4/14/2022 3:28 PM, Ben wrote:
>> > olcott <No...@NoWhere.com> writes:
>> >> As long as the correctly simulated input to H(P,P) would never halt
>> >> then we know it is non-halting.
>> >
>> > Readers beware! Ask yourselves why PO does not say the simpler "never
>> > halts", but instead says "/would/ never halt". Why the implied
>> > subjunctive mood?
>> A simulating halt decider must correctly predict the future behavior of
>> of its simulated input. Many of my readers get confused and believe that
>> an aborted simulation means that the simulated input has halted.
>>
>> To an academic audience of computer scientists I would simply say that
>> the behavior of the simulated input to H(P,P) conclusively proves that
>> it is non-halting.
>>
> You have set up a confusing system, because a simulator is simulating
> a simulator. Eventually one of the simulators decides that the system
> of simulators simulating simultators will go on forever, and halts.

I'd prefer it if you said partial simulator. I've urged PO not to
bother saying correct simulation, but he'll have to if you use the naked
term for something that is not a correct simulator.

Also, one way or another, the top-level simulation must stop (regardless
of what's being simulated) or it can't be used as a decider.

--
Ben.

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

<IEf6K.167451$8V_7.91526@fx04.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx04.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>
<74KdnQt1sMVb3M__nZ2dnUU7_83NnZ2d@giganews.com> <87mtgt541v.fsf@bsb.me.uk>
<op-dncDOwP0Knc7_nZ2dnUU7_8zNnZ2d@giganews.com> <8735ik63ip.fsf@bsb.me.uk>
<NOCdnZKexLqX0c7_nZ2dnUU7_8zNnZ2d@giganews.com> <87ee244h7c.fsf@bsb.me.uk>
<N-adnUIFw_v06M7_nZ2dnUU7_8zNnZ2d@giganews.com> <87lewb2n1l.fsf@bsb.me.uk>
<H8-dnVGrq8R9X8n_nZ2dnUU7_83NnZ2d@giganews.com> <t32id1$qma$1@dont-email.me>
<X4-dnQGRJqf1UMn_nZ2dnUU7_81g4p2d@giganews.com> <t3832d$dpk$1@dont-email.me>
<mdSdnSArnKkADcr_nZ2dnUU7_8xh4p2d@giganews.com> <t3861c$tbc$1@dont-email.me>
<V4ydnbyFmPX4Acr_nZ2dnUU7_8zNnZ2d@giganews.com> <877d7ru6vm.fsf@bsb.me.uk>
<77mdnbyuM9iGrsX_nZ2dnUU7_81g4p2d@giganews.com> <878rs7s92t.fsf@bsb.me.uk>
<8rmdncC5Nb6LGsX_nZ2dnUU7_8zNnZ2d@giganews.com>
<73f32808-6d8b-4ab3-9eac-74c4d7634c26n@googlegroups.com>
<874k2uquqy.fsf@bsb.me.uk>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <874k2uquqy.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 37
Message-ID: <IEf6K.167451$8V_7.91526@fx04.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: Fri, 15 Apr 2022 10:52:24 -0400
X-Received-Bytes: 3588
 by: Richard Damon - Fri, 15 Apr 2022 14:52 UTC

On 4/15/22 10:36 AM, Ben wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Thursday, 14 April 2022 at 21:42:05 UTC+1, olcott wrote:
>>> On 4/14/2022 3:28 PM, Ben wrote:
>>>> olcott <No...@NoWhere.com> writes:
>>>>> As long as the correctly simulated input to H(P,P) would never halt
>>>>> then we know it is non-halting.
>>>>
>>>> Readers beware! Ask yourselves why PO does not say the simpler "never
>>>> halts", but instead says "/would/ never halt". Why the implied
>>>> subjunctive mood?
>>> A simulating halt decider must correctly predict the future behavior of
>>> of its simulated input. Many of my readers get confused and believe that
>>> an aborted simulation means that the simulated input has halted.
>>>
>>> To an academic audience of computer scientists I would simply say that
>>> the behavior of the simulated input to H(P,P) conclusively proves that
>>> it is non-halting.
>>>
>> You have set up a confusing system, because a simulator is simulating
>> a simulator. Eventually one of the simulators decides that the system
>> of simulators simulating simultators will go on forever, and halts.
>
> I'd prefer it if you said partial simulator. I've urged PO not to
> bother saying correct simulation, but he'll have to if you use the naked
> term for something that is not a correct simulator.
>
> Also, one way or another, the top-level simulation must stop (regardless
> of what's being simulated) or it can't be used as a decider.
>

And if the top-level simulation stops, then so must the identical copy
processing the identical input that it is simulating.

Some how PO seems to think that this isn't actually so, an idea that if
true would wipe out all of Computer Science.

Pages:12345678910111213141516171819202122232425262728293031323334353637383940
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor