Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Decaffeinated coffee? Just Say No.


devel / comp.theory / Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

SubjectAuthor
* How do we know H(P,P)==0 is the correct halt status for the input toolcott
+- How do we know H(P,P)==0 is the correct halt status for the inputolcott
+* How do we know H(P,P)==0 is the correct halt status for the inputwij
|`* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| +* How do we know H(P,P)==0 is the correct halt status for the inputwij
| |`* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | +* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |`* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | | `* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |  `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |   `* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |    `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |     +- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |     `* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |      `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       +* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |`* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       | `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |  `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |   `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |    `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |     `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |      `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |       `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |        `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |         `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |          `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |           `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |            `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |             `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |              `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |               `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                 `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                  `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                   `* How do we know H(P,P)==0 is the correct halt status for the input to H?Richard Damon
| | |       |                    `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                     `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                      `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                       `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                        `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         +* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                         |+* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         ||`* How do we know H(P,P)==0 is the correct halt status for the input to H?Richard Damon
| | |       |                         || `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                         ||  `- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                         |`* How do we know H(P,P)==0 is the correct halt status for the inputMalcolm McLean
| | |       |                         | +- How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                         | `* How do we know H(P,P)==0 is the correct halt status for the inputMalcolm McLean
| | |       |                         |  +* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         |  |`* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  | `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         |  |  `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |   `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                         |  |    `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |     `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         |  |      `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |       `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                         |  |        `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |         `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                         |  |          `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |           `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                         |  |            `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |             `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         |  |              `* How do we know H(P,P)==0 is the correct halt status for the inputAndré G. Isaak
| | |       |                         |  |               `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         |  |                `- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                         |  `* How do we know H(P,P)==0 is the correct halt status for the inputMalcolm McLean
| | |       |                         |   `- How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |       |                         `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                          +* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       |                          |`* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                          | `* How do we know H(P,P)==0 is the correct halt status for the input to H? [ key axolcott
| | |       |                          |  `- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |       |                          `* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |       |                           `- How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |       `* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |        `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |         `* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |          +* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |          |`* How do we know H(P,P)==0 is the correct halt status for the inputwij
| | |          | +- How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |          | `* How do we know H(P,P)==0 is the correct halt status for the inputdklei...@gmail.com
| | |          |  `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |          |   `* How do we know H(P,P)==0 is the correct halt status for the input to H?Richard Damon
| | |          |    `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |          |     `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |          |      `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| | |          |       `- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |          `* How do we know H(P,P)==0 is the correct halt status for the inputChris M. Thomasson
| | |           `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| | |            `* How do we know H(P,P)==0 is the correct halt status for the inputChris M. Thomasson
| | |             `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |              `* How do we know H(P,P)==0 is the correct halt status for the inputChris M. Thomasson
| | |               `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |                `* How do we know H(P,P)==0 is the correct halt status for the inputChris M. Thomasson
| | |                 `* How do we know H(P,P)==0 is the correct halt status for the input to H?olcott
| | |                  `- How do we know H(P,P)==0 is the correct halt status for the input to H?Ben Bacarisse
| | `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| |  `* How do we know H(P,P)==0 is the correct halt status for the inputolcott
| |   `- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
| `* How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
+- How do we know H(P,P)==0 is the correct halt status for the inputRichard Damon
`* How do we know H(P,P)==0 is the correct halt status for the input to H?Ben Bacarisse

Pages:12345678910111213141516171819
Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ conversation has ended? ]

<00f90a55-4b7f-4c19-a9b8-53a42ee561a6n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:4659:: with SMTP id f25mr5443452qto.143.1630012486300;
Thu, 26 Aug 2021 14:14:46 -0700 (PDT)
X-Received: by 2002:a25:bb8b:: with SMTP id y11mr935685ybg.384.1630012486016;
Thu, 26 Aug 2021 14:14:46 -0700 (PDT)
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Thu, 26 Aug 2021 14:14:45 -0700 (PDT)
In-Reply-To: <e6ednTD_zcKqKLr8nZ2dnUU7-bPNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=47.208.130.96; posting-account=7Xc2EwkAAABXMcQfERYamr3b-64IkBws
NNTP-Posting-Host: 47.208.130.96
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<cradndCzBKW6Ir_8nZ2dnUU7-XWdnZ2d@giganews.com> <87o89pf5zi.fsf@bsb.me.uk>
<R_WdnWjO0dnDlb78nZ2dnUU7-bvNnZ2d@giganews.com> <87k0kce1yk.fsf@bsb.me.uk>
<edCdnTY_IvB2N778nZ2dnUU7-WvNnZ2d@giganews.com> <87bl5oc62l.fsf@bsb.me.uk>
<INadnSiJbfTFYb78nZ2dnUU7-LPNnZ2d@giganews.com> <87tujfbv4y.fsf@bsb.me.uk>
<5bidne_8HrBuqbn8nZ2dnUU7-dfNnZ2d@giganews.com> <87lf4rbksk.fsf@bsb.me.uk>
<Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com> <87fsuzaq8t.fsf@bsb.me.uk>
<__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com> <87zgt69xah.fsf@bsb.me.uk>
<tqadndv0qJ8vOLj8nZ2dnUU7-R_NnZ2d@giganews.com> <1LCdnZZtHK3SK7j8nZ2dnUU7-R_NnZ2d@giganews.com>
<87lf4pa56n.fsf@bsb.me.uk> <feudnRmpetF2G7v8nZ2dnUU7-VfNnZ2d@giganews.com>
<87czq19wx0.fsf@bsb.me.uk> <Y7adnS3RyacCCbv8nZ2dnUU7-UWdnZ2d@giganews.com>
<874kbcaojh.fsf@bsb.me.uk> <CMDVI.3286$nR3.588@fx38.iad> <eISdnXNd1-AYkrr8nZ2dnUU7-eednZ2d@giganews.com>
<03a1142a-040f-43d6-bb5c-dcc3ba2f5499n@googlegroups.com> <e6ednTD_zcKqKLr8nZ2dnUU7-bPNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <00f90a55-4b7f-4c19-a9b8-53a42ee561a6n@googlegroups.com>
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ conversation has ended? ]
From: dkleine...@gmail.com (dklei...@gmail.com)
Injection-Date: Thu, 26 Aug 2021 21:14:46 +0000
Content-Type: text/plain; charset="UTF-8"
 by: dklei...@gmail.com - Thu, 26 Aug 2021 21:14 UTC

On Thursday, August 26, 2021 at 8:37:34 AM UTC-7, olcott wrote:
> On 8/26/2021 10:25 AM, dklei...@gmail.com wrote:
> > On Wednesday, August 25, 2021 at 8:50:37 PM UTC-7, olcott wrote:
> >
> >> Simulating Halt Decider Theorem (Olcott 2020):
> >
> >> A simulating halt decider correctly decides that any input that never
> >> halts unless the simulating halt decider aborts its simulation of this
> >> input is an input that never halts.
> >
> > Now we need definitions of
> > (1) simulating halt decider
> > (2) input that never halts unless the simulating halt decider aborts
> > its simulation of this input
> > (3) input that never halts.
> > (4) decides
> >
> > It looks obvious. (2) "X such that .." is an obvious subset of (3) X
> >
> > Unless that is not what (2) means
> >
> This merely relies upon the conventional computational equivalence
> between the direct execution of a TM and the simulation of a TM
> description by a UTM.
>
> Every TM description that would never halt on its input while a
> simulating halt decider is simulating it in pure simulation mode defines
> an identical set to the set of computations that never halt.

Unnecessarily complicated. The "theorem" is so simple and very general
as I noted. The problem with it is that set of inputs that never halt is
empty. Halt deciders, by definition always halt.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ conversation has ended? ]

<xo2dnY5d8fbgj7X8nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 26 Aug 2021 17:15:25 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ conversation has ended? ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <87k0kce1yk.fsf@bsb.me.uk> <edCdnTY_IvB2N778nZ2dnUU7-WvNnZ2d@giganews.com> <87bl5oc62l.fsf@bsb.me.uk> <INadnSiJbfTFYb78nZ2dnUU7-LPNnZ2d@giganews.com> <87tujfbv4y.fsf@bsb.me.uk> <5bidne_8HrBuqbn8nZ2dnUU7-dfNnZ2d@giganews.com> <87lf4rbksk.fsf@bsb.me.uk> <Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com> <87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com> <87zgt69xah.fsf@bsb.me.uk> <tqadndv0qJ8vOLj8nZ2dnUU7-R_NnZ2d@giganews.com> <1LCdnZZtHK3SK7j8nZ2dnUU7-R_NnZ2d@giganews.com> <87lf4pa56n.fsf@bsb.me.uk> <feudnRmpetF2G7v8nZ2dnUU7-VfNnZ2d@giganews.com> <87czq19wx0.fsf@bsb.me.uk> <Y7adnS3RyacCCbv8nZ2dnUU7-UWdnZ2d@giganews.com> <874kbcaojh.fsf@bsb.me.uk> <CMDVI.3286$nR3.588@fx38.iad> <eISdnXNd1-AYkrr8nZ2dnUU7-eednZ2d@giganews.com> <03a1142a-040f-43d6-bb5c-dcc3ba2f5499n@googlegroups.com> <e6ednTD_zcKqKLr8nZ2dnUU7-bPNnZ2d@giganews.com> <00f90a55-4b7f-4c19-a9b8-53a42ee561a6n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 26 Aug 2021 17:15:23 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <00f90a55-4b7f-4c19-a9b8-53a42ee561a6n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <xo2dnY5d8fbgj7X8nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-s13fwuH3ka6HdolMDu9OJlVPepuHlApU39OKPXBb0eR4MVuNKq1kxirx9qFj/HyqE+8Ip5SmQDhRiJo!ksFktUTD3IMlgmWOqKluRUL7M/+LXDZEZSJ971QmOgFfjI88ClaaDFim/56XQ3r44ga/jLqka9fL!d5s=
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: 4193
 by: olcott - Thu, 26 Aug 2021 22:15 UTC

On 8/26/2021 4:14 PM, dklei...@gmail.com wrote:
> On Thursday, August 26, 2021 at 8:37:34 AM UTC-7, olcott wrote:
>> On 8/26/2021 10:25 AM, dklei...@gmail.com wrote:
>>> On Wednesday, August 25, 2021 at 8:50:37 PM UTC-7, olcott wrote:
>>>
>>>> Simulating Halt Decider Theorem (Olcott 2020):
>>>
>>>> A simulating halt decider correctly decides that any input that never
>>>> halts unless the simulating halt decider aborts its simulation of this
>>>> input is an input that never halts.
>>>
>>> Now we need definitions of
>>> (1) simulating halt decider
>>> (2) input that never halts unless the simulating halt decider aborts
>>> its simulation of this input
>>> (3) input that never halts.
>>> (4) decides
>>>
>>> It looks obvious. (2) "X such that .." is an obvious subset of (3) X
>>>
>>> Unless that is not what (2) means
>>>
>> This merely relies upon the conventional computational equivalence
>> between the direct execution of a TM and the simulation of a TM
>> description by a UTM.
>>
>> Every TM description that would never halt on its input while a
>> simulating halt decider is simulating it in pure simulation mode defines
>> an identical set to the set of computations that never halt.
>
> Unnecessarily complicated. The "theorem" is so simple and very general
> as I noted. The problem with it is that set of inputs that never halt is
> empty. Halt deciders, by definition always halt.
>

void Infinite_Loop()
{ HERE: goto HERE;
}

It is pretty clear that the above input never halts.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

The point is that it decides the halt status of all of the conventional
HP proof "impossible' inputs correctly thus refuting all of these proofs.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<%dVVI.4471$o45.2514@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com>
<87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com>
<5zqVI.10579$kQ4.10540@fx13.iad>
<Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad>
<Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk>
<eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me>
<IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 23
Message-ID: <%dVVI.4471$o45.2514@fx46.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, 26 Aug 2021 19:12:59 -0400
X-Received-Bytes: 2761
 by: Richard Damon - Thu, 26 Aug 2021 23:12 UTC

On 8/26/21 2:10 PM, olcott wrote:
> On 8/26/2021 1:03 PM, André G. Isaak wrote:

>> And if you don't know exactly how a UTM works, then how do you plan on
>> establishing that a 'simulating halt decider' based on a UTM can
>> recognize a given sequence of steps as being infinite?
>>
>> André
>>
>
> A UTM must simulate the code that it is presented with. If this code
> writes to its tape the it must literally write to its tape.
>

Right, but it write the representation of that data, not the data itself.

Remember the machine that the UTM is running on, and thus that 'symbol
set' of the tape may be very different than the symbol set of the
machine that it is simulating, so there is an encoding issue.

THere also needs to be an encoding of where the tape is, since the
actual tape the UTM is using will be moving to other spots.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<biVVI.4472$o45.2372@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87tujfbv4y.fsf@bsb.me.uk> <5bidne_8HrBuqbn8nZ2dnUU7-dfNnZ2d@giganews.com>
<87lf4rbksk.fsf@bsb.me.uk> <Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com>
<87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com>
<87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com>
<87r1eha6x8.fsf@bsb.me.uk> <yK2dnZkA2Nsu5Lv8nZ2dnUU7-THNnZ2d@giganews.com>
<_8BVI.106$GD7.95@fx23.iad> <FaydnfJTMNyofrv8nZ2dnUU7-e3NnZ2d@giganews.com>
<i7CVI.13$jl2.7@fx34.iad> <5Y6dndhJqqgGcrv8nZ2dnUU7-RWdnZ2d@giganews.com>
<ihCVI.186$2B4.3@fx04.iad> <CeidnS_08apsaLv8nZ2dnUU7-RmdnZ2d@giganews.com>
<sg6ss9$o8n$1@dont-email.me> <SZ-dncSHQLR3Z7v8nZ2dnUU7-W2dnZ2d@giganews.com>
<VdDVI.486$lC6.43@fx41.iad> <LfednRsEJtD1mbr8nZ2dnUU7-bHNnZ2d@giganews.com>
<WIDVI.5960$Kv2.3004@fx47.iad>
<eISdnXBd1-CTkrr8nZ2dnUU7-eednZ2d@giganews.com> <XgKVI.13$tG6.4@fx39.iad>
<eeydndtCipmXDbr8nZ2dnUU7-YfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <eeydndtCipmXDbr8nZ2dnUU7-YfNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Lines: 94
Message-ID: <biVVI.4472$o45.2372@fx46.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, 26 Aug 2021 19:17:27 -0400
X-Received-Bytes: 5519
 by: Richard Damon - Thu, 26 Aug 2021 23:17 UTC

On 8/26/21 8:58 AM, olcott wrote:
> On 8/26/2021 5:45 AM, Richard Damon wrote:
>> On 8/25/21 11:48 PM, olcott wrote:
>>> On 8/25/2021 10:17 PM, Richard Damon wrote:
>>>> On 8/25/21 11:03 PM, olcott wrote:
>>>>> On 8/25/2021 9:44 PM, Richard Damon wrote:
>>>>>> On 8/25/21 10:22 PM, olcott wrote:
>>>>>>> On 8/25/2021 9:04 PM, Richard Damon wrote:
>>>>>>>> On 8/25/21 10:01 PM, olcott wrote:
>>>>>>>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>>>>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>>>>>>>> H(<H^>,<H^>)
>>>>>>>>>>>> says non-halting it was wrong.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That was your last chance.
>>>>>>>>>>
>>>>>>>>>> You admit defeat?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I acknowledge that you are an incorrigible jackass.
>>>>>>>>> The review process moves to phase two.
>>>>>>>>>
>>>>>>>>
>>>>>>>> What does that mean? You going to write the paper to submit to get
>>>>>>>> your
>>>>>>>> rejection?
>>>>>>>>
>>>>>>>> You have yet to show anywhere whre my basic objections are
>>>>>>>> incorrect.
>>>>>>>>
>>>>>>>
>>>>>>> You know full well that your "objections" are pure drivel.
>>>>>>
>>>>>> No, I, and everyone else who is reading this will see that what I say
>>>>>> makes sense.
>>>>>>
>>>>>> YOUR statements are the 'pure drivel'.
>>>>>>
>>>>>> Please note that basically no one belives your statements and
>>>>>> everyone
>>>>>> thinks you are wrong. While it is possible that you have discovered
>>>>>> some
>>>>>> hidden secret, it is very unlikely. One key thing to ask yourself,
>>>>>> what
>>>>>> grounds do I have to actually expect that I could come up with some
>>>>>> insite like that that no one else beleives.
>>>>> Because of this my work is not getting an honest review. It is obvious
>>>>> that my work is not getting an honest review to anyone knowing the
>>>>> material very well that all of the "rebuttals" simply dodge directly
>>>>> assessing my points and change to subject to some other points.
>>>>>
>>>>
>>>> No, it HAS gotten an Honest review, and you just don't want to accept
>>>> it, because it shows how BAD your logic is.
>>>>
>>>
>>> You cannot correctly point to any actual mistake in the essence of my
>>> proof. All you can do is talk in circles.
>>>
>>>
>>
>> You mean like the false assumption that H makes that the copy of H that
>> it is simulating will NEVER abort its simulation, when it is clear that,
>> at least if H is a computation, that it will as another identical copy
>> of the computation does.
>>
>
> It is a verified fact that if H waits for some other H to abort the
> simulation that every H waits for some other H to abort the simulation
> and the simulation is never aborted because every H has the exact same
> code.

Yes, if you change EVERY H to wait longer, then you just changed H^ and
thus you need to start over. That is an invalid transformation.

The key is that you need to change JUST THAT INSTANCE of H, and then you
can see what would happen if it ran longer.

For some reason you don't understand this, and it is also true that the
way you are reusing the physical cod, and address space,e actually
breaks your Turing Equivalence, but since you don't understand how
Turing MAchines work, you just don't understand that.

>
>> The only conclusion here is that either your H is unsound or it isn't a
>> computation, and thus isn't eligible to even be a halt decider.
>>
>
>

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 26 Aug 2021 18:19:28 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com> <87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com> <5zqVI.10579$kQ4.10540@fx13.iad> <Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad> <Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com> <p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me> <0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me> <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com> <%dVVI.4471$o45.2514@fx46.iad>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 26 Aug 2021 18:19:27 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <%dVVI.4471$o45.2514@fx46.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com>
Lines: 33
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6nv/+4d11abgM+wTAbDUIy9SuoraMLzM2G2Yo2D7cA4B6sS0KXthwAEqQKbBJ/0rJrpCcoR++/dz0IA!z0HQ0uf0VpI4CgD4PrRTEGlx5UL6YDSeO1KGruF0XxxIf9Yc3Rd/fQj31Dkl92U1QvAMraDyVTqb!P80=
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: 3378
 by: olcott - Thu, 26 Aug 2021 23:19 UTC

On 8/26/2021 6:12 PM, Richard Damon wrote:
> On 8/26/21 2:10 PM, olcott wrote:
>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>
>>> And if you don't know exactly how a UTM works, then how do you plan on
>>> establishing that a 'simulating halt decider' based on a UTM can
>>> recognize a given sequence of steps as being infinite?
>>>
>>> André
>>>
>>
>> A UTM must simulate the code that it is presented with. If this code
>> writes to its tape the it must literally write to its tape.
>>
>
> Right, but it write the representation of that data, not the data itself.
>
> Remember the machine that the UTM is running on, and thus that 'symbol
> set' of the tape may be very different than the symbol set of the
> machine that it is simulating, so there is an encoding issue.
>
> THere also needs to be an encoding of where the tape is, since the
> actual tape the UTM is using will be moving to other spots.
>

All of that merely dodges Ben's mistake.
You really can't seem to stay focused on the pint at hand.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<e5qdne9vgZtEvLX8nZ2dnUU7-WednZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 26 Aug 2021 18:20:57 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <87tujfbv4y.fsf@bsb.me.uk> <5bidne_8HrBuqbn8nZ2dnUU7-dfNnZ2d@giganews.com> <87lf4rbksk.fsf@bsb.me.uk> <Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com> <87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com> <87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com> <87r1eha6x8.fsf@bsb.me.uk> <yK2dnZkA2Nsu5Lv8nZ2dnUU7-THNnZ2d@giganews.com> <_8BVI.106$GD7.95@fx23.iad> <FaydnfJTMNyofrv8nZ2dnUU7-e3NnZ2d@giganews.com> <i7CVI.13$jl2.7@fx34.iad> <5Y6dndhJqqgGcrv8nZ2dnUU7-RWdnZ2d@giganews.com> <ihCVI.186$2B4.3@fx04.iad> <CeidnS_08apsaLv8nZ2dnUU7-RmdnZ2d@giganews.com> <sg6ss9$o8n$1@dont-email.me> <SZ-dncSHQLR3Z7v8nZ2dnUU7-W2dnZ2d@giganews.com> <VdDVI.486$lC6.43@fx41.iad> <LfednRsEJtD1mbr8nZ2dnUU7-bHNnZ2d@giganews.com> <WIDVI.5960$Kv2.3004@fx47.iad> <eISdnXBd1-CTkrr8nZ2dnUU7-eednZ2d@giganews.com> <XgKVI.13$tG6.4@fx39.iad> <eeydndtCipmXDbr8nZ2dnUU7-YfNnZ2d@giganews.com> <biVVI.4472$o45.2372@fx46.iad>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 26 Aug 2021 18:20:56 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <biVVI.4472$o45.2372@fx46.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <e5qdne9vgZtEvLX8nZ2dnUU7-WednZ2d@giganews.com>
Lines: 87
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-7X9ckUsG52YTKkq6pVT+tm9G5jz44vjjeNyR+J1mfIryXdF6dasGOniEeRgBynHruQEBQyVgRz4a/qo!Q6vyEpKX83mQM0ElyfigVRKg/gs//nJ/56afig961tPSLScpwqiJ4z589HwiSvsAXC4vr/RQH2/d!v34=
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: 5492
 by: olcott - Thu, 26 Aug 2021 23:20 UTC

On 8/26/2021 6:17 PM, Richard Damon wrote:
> On 8/26/21 8:58 AM, olcott wrote:
>> On 8/26/2021 5:45 AM, Richard Damon wrote:
>>> On 8/25/21 11:48 PM, olcott wrote:
>>>> On 8/25/2021 10:17 PM, Richard Damon wrote:
>>>>> On 8/25/21 11:03 PM, olcott wrote:
>>>>>> On 8/25/2021 9:44 PM, Richard Damon wrote:
>>>>>>> On 8/25/21 10:22 PM, olcott wrote:
>>>>>>>> On 8/25/2021 9:04 PM, Richard Damon wrote:
>>>>>>>>> On 8/25/21 10:01 PM, olcott wrote:
>>>>>>>>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>>>>>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>>>>>>>>> H(<H^>,<H^>)
>>>>>>>>>>>>> says non-halting it was wrong.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That was your last chance.
>>>>>>>>>>>
>>>>>>>>>>> You admit defeat?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I acknowledge that you are an incorrigible jackass.
>>>>>>>>>> The review process moves to phase two.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> What does that mean? You going to write the paper to submit to get
>>>>>>>>> your
>>>>>>>>> rejection?
>>>>>>>>>
>>>>>>>>> You have yet to show anywhere whre my basic objections are
>>>>>>>>> incorrect.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You know full well that your "objections" are pure drivel.
>>>>>>>
>>>>>>> No, I, and everyone else who is reading this will see that what I say
>>>>>>> makes sense.
>>>>>>>
>>>>>>> YOUR statements are the 'pure drivel'.
>>>>>>>
>>>>>>> Please note that basically no one belives your statements and
>>>>>>> everyone
>>>>>>> thinks you are wrong. While it is possible that you have discovered
>>>>>>> some
>>>>>>> hidden secret, it is very unlikely. One key thing to ask yourself,
>>>>>>> what
>>>>>>> grounds do I have to actually expect that I could come up with some
>>>>>>> insite like that that no one else beleives.
>>>>>> Because of this my work is not getting an honest review. It is obvious
>>>>>> that my work is not getting an honest review to anyone knowing the
>>>>>> material very well that all of the "rebuttals" simply dodge directly
>>>>>> assessing my points and change to subject to some other points.
>>>>>>
>>>>>
>>>>> No, it HAS gotten an Honest review, and you just don't want to accept
>>>>> it, because it shows how BAD your logic is.
>>>>>
>>>>
>>>> You cannot correctly point to any actual mistake in the essence of my
>>>> proof. All you can do is talk in circles.
>>>>
>>>>
>>>
>>> You mean like the false assumption that H makes that the copy of H that
>>> it is simulating will NEVER abort its simulation, when it is clear that,
>>> at least if H is a computation, that it will as another identical copy
>>> of the computation does.
>>>
>>
>> It is a verified fact that if H waits for some other H to abort the
>> simulation that every H waits for some other H to abort the simulation
>> and the simulation is never aborted because every H has the exact same
>> code.
>
> Yes, if you change EVERY H

H is required to be a single machine or the HP proof is not refuted.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ conversation has ended? ]

<zuWVI.1055$2Q_3.854@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ conversation has ended? ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87o89pf5zi.fsf@bsb.me.uk> <R_WdnWjO0dnDlb78nZ2dnUU7-bvNnZ2d@giganews.com>
<87k0kce1yk.fsf@bsb.me.uk> <edCdnTY_IvB2N778nZ2dnUU7-WvNnZ2d@giganews.com>
<87bl5oc62l.fsf@bsb.me.uk> <INadnSiJbfTFYb78nZ2dnUU7-LPNnZ2d@giganews.com>
<87tujfbv4y.fsf@bsb.me.uk> <5bidne_8HrBuqbn8nZ2dnUU7-dfNnZ2d@giganews.com>
<87lf4rbksk.fsf@bsb.me.uk> <Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com>
<87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com>
<87zgt69xah.fsf@bsb.me.uk> <tqadndv0qJ8vOLj8nZ2dnUU7-R_NnZ2d@giganews.com>
<1LCdnZZtHK3SK7j8nZ2dnUU7-R_NnZ2d@giganews.com> <87lf4pa56n.fsf@bsb.me.uk>
<feudnRmpetF2G7v8nZ2dnUU7-VfNnZ2d@giganews.com> <87czq19wx0.fsf@bsb.me.uk>
<Y7adnS3RyacCCbv8nZ2dnUU7-UWdnZ2d@giganews.com> <874kbcaojh.fsf@bsb.me.uk>
<CMDVI.3286$nR3.588@fx38.iad> <eISdnXNd1-AYkrr8nZ2dnUU7-eednZ2d@giganews.com>
<fdKVI.12$tG6.10@fx39.iad> <Oa6dnSl31ap5E7r8nZ2dnUU7-bPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <Oa6dnSl31ap5E7r8nZ2dnUU7-bPNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 94
Message-ID: <zuWVI.1055$2Q_3.854@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, 26 Aug 2021 20:38:54 -0400
X-Received-Bytes: 5499
 by: Richard Damon - Fri, 27 Aug 2021 00:38 UTC

On 8/26/21 8:53 AM, olcott wrote:
> On 8/26/2021 5:41 AM, Richard Damon wrote:
>> On 8/25/21 11:50 PM, olcott wrote:
>>> On 8/25/2021 10:21 PM, Richard Damon wrote:
>>>> On 8/25/21 11:10 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>> Too disingenuous to continue.
>>>>>
>>>>> Excellent!  Mind you, you've said you won't talk go to me many times
>>>>> before and I always end up disappointed.
>>>>>
>>>>
>>>> Yes, me too. It is clear that when people clearly point out his
>>>> mistakes, his brain starts to go crazy and he finds it irresistible to
>>>> lash out and try to muddy the air with some illogic to try and hide the
>>>> clear rebuttal.
>>>>
>>>> I think he hopes that the thread will go off some other direction and
>>>> the clear rebuttal will be forgotten.
>>>>
>>>> THAT is why he calls them 'dishonest dodges', he thinks if he says that
>>>> enough some people might beleive it and not look at them.
>>>>
>>>
>>> This is the crux of my whole proof try and refute it without changing
>>> the subject or talking in circles:
>>>
>>> Simulating Halt Decider Theorem (Olcott 2020):
>>> A simulating halt decider correctly decides that any input that never
>>> halts unless the simulating halt decider aborts its simulation of this
>>> input is an input that never halts.
>>>
>>
>> Easy, Fundamental Definitions (do you disagree with any of these):
>>
>> The Definition of a Computation: The act of performing a Step by Step
>> Algorithm on an input data to get an answer. The Algorithm needs to
>> precisely state exactly what operations to perform and the input needs
>> to specify all the variable data for the caluclation.
>>
>> Since a Computation fully specifies what is done and what it is done on,
>> every time you run a given computation on the same data you will get the
>> same answer.
>>
>> The Definition of A Halting Computation is CDomputatiion that reaches a
>> halting state in a finite numb4r of steps. A Non-Halting one is one that
>> never reaches a Halting state for ANY finite number of Steps.
>>
>> The Definition of a Halt Decider: A Computation that, when given as an
>> input the representation of a Computation, is able to correctly indicate
>> if that Computation is Halting or Non-Halting.
>>
>> Thus the right answer isn't based on a partial simulation performed by
>> the decider, but on what the actual machine does.
>>
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H1((u32)P, (u32)P));
> }
>
> H1 determines that its input halts on its input on the basis that H
> determines that its input never halts.

Yes H THINKS its input never halts, but since the input to H is the
exact same input as to H1, the machine it represents is the same, so its
behavior MUST be the same.

Think about what you are trying to claim.

THere is a single question, what is the behavior of the machine P(P)?

You ask this of two different deciders.

They give different answers, but you claim they both are correct?

Remember, the question ISN'T will machine X simulate the machine to a
halt state, the only true actual Halting Question is what is the
behavior of the machine that the input represents? Is it halting or not.

THAT IS THE DEFINITION.

It CAN'T be different for different deciders, as the question isn't
about the decider, it is about the machine that the input represents.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<OGWVI.12677$Kv2.11978@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87lf4rbksk.fsf@bsb.me.uk> <Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com>
<87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com>
<87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com>
<87r1eha6x8.fsf@bsb.me.uk> <yK2dnZkA2Nsu5Lv8nZ2dnUU7-THNnZ2d@giganews.com>
<_8BVI.106$GD7.95@fx23.iad> <FaydnfJTMNyofrv8nZ2dnUU7-e3NnZ2d@giganews.com>
<i7CVI.13$jl2.7@fx34.iad> <5Y6dndhJqqgGcrv8nZ2dnUU7-RWdnZ2d@giganews.com>
<ihCVI.186$2B4.3@fx04.iad> <CeidnS_08apsaLv8nZ2dnUU7-RmdnZ2d@giganews.com>
<sg6ss9$o8n$1@dont-email.me> <SZ-dncSHQLR3Z7v8nZ2dnUU7-W2dnZ2d@giganews.com>
<VdDVI.486$lC6.43@fx41.iad> <LfednRsEJtD1mbr8nZ2dnUU7-bHNnZ2d@giganews.com>
<WIDVI.5960$Kv2.3004@fx47.iad>
<eISdnXBd1-CTkrr8nZ2dnUU7-eednZ2d@giganews.com> <XgKVI.13$tG6.4@fx39.iad>
<eeydndtCipmXDbr8nZ2dnUU7-YfNnZ2d@giganews.com>
<biVVI.4472$o45.2372@fx46.iad>
<e5qdne9vgZtEvLX8nZ2dnUU7-WednZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <e5qdne9vgZtEvLX8nZ2dnUU7-WednZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Lines: 115
Message-ID: <OGWVI.12677$Kv2.11978@fx47.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, 26 Aug 2021 20:51:57 -0400
X-Received-Bytes: 6630
 by: Richard Damon - Fri, 27 Aug 2021 00:51 UTC

On 8/26/21 7:20 PM, olcott wrote:
> On 8/26/2021 6:17 PM, Richard Damon wrote:
>> On 8/26/21 8:58 AM, olcott wrote:
>>> On 8/26/2021 5:45 AM, Richard Damon wrote:
>>>> On 8/25/21 11:48 PM, olcott wrote:
>>>>> On 8/25/2021 10:17 PM, Richard Damon wrote:
>>>>>> On 8/25/21 11:03 PM, olcott wrote:
>>>>>>> On 8/25/2021 9:44 PM, Richard Damon wrote:
>>>>>>>> On 8/25/21 10:22 PM, olcott wrote:
>>>>>>>>> On 8/25/2021 9:04 PM, Richard Damon wrote:
>>>>>>>>>> On 8/25/21 10:01 PM, olcott wrote:
>>>>>>>>>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>>>>>>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>>>>>>>>>> H(<H^>,<H^>)
>>>>>>>>>>>>>> says non-halting it was wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That was your last chance.
>>>>>>>>>>>>
>>>>>>>>>>>> You admit defeat?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I acknowledge that you are an incorrigible jackass.
>>>>>>>>>>> The review process moves to phase two.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> What does that mean? You going to write the paper to submit to
>>>>>>>>>> get
>>>>>>>>>> your
>>>>>>>>>> rejection?
>>>>>>>>>>
>>>>>>>>>> You have yet to show anywhere whre my basic objections are
>>>>>>>>>> incorrect.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You know full well that your "objections" are pure drivel.
>>>>>>>>
>>>>>>>> No, I, and everyone else who is reading this will see that what
>>>>>>>> I say
>>>>>>>> makes sense.
>>>>>>>>
>>>>>>>> YOUR statements are the 'pure drivel'.
>>>>>>>>
>>>>>>>> Please note that basically no one belives your statements and
>>>>>>>> everyone
>>>>>>>> thinks you are wrong. While it is possible that you have discovered
>>>>>>>> some
>>>>>>>> hidden secret, it is very unlikely. One key thing to ask yourself,
>>>>>>>> what
>>>>>>>> grounds do I have to actually expect that I could come up with some
>>>>>>>> insite like that that no one else beleives.
>>>>>>> Because of this my work is not getting an honest review. It is
>>>>>>> obvious
>>>>>>> that my work is not getting an honest review to anyone knowing the
>>>>>>> material very well that all of the "rebuttals" simply dodge directly
>>>>>>> assessing my points and change to subject to some other points.
>>>>>>>
>>>>>>
>>>>>> No, it HAS gotten an Honest review, and you just don't want to accept
>>>>>> it, because it shows how BAD your logic is.
>>>>>>
>>>>>
>>>>> You cannot correctly point to any actual mistake in the essence of my
>>>>> proof. All you can do is talk in circles.
>>>>>
>>>>>
>>>>
>>>> You mean like the false assumption that H makes that the copy of H that
>>>> it is simulating will NEVER abort its simulation, when it is clear
>>>> that,
>>>> at least if H is a computation, that it will as another identical copy
>>>> of the computation does.
>>>>
>>>
>>> It is a verified fact that if H waits for some other H to abort the
>>> simulation that every H waits for some other H to abort the simulation
>>> and the simulation is never aborted because every H has the exact same
>>> code.
>>
>> Yes, if you change EVERY H
>
> H is required to be a single machine or the HP proof is not refuted.
>
>

Yes, H is *A* machine, so it has a SPECIFIC definition, SPECIFIED BEFORE
YOU GET INTO THE PROOF.

Thus, every time YOU talk about a change to H, you just broke the rules
of the proof and have to start over.

When you posit questions about if H ..., you are outside the proof. Any
of your if H ... must be a factual Truth Bearer (or is illogical).

If H doesn't abort the simulation, well that statement is either TRUE,
or it is FALSE. IF it is True, that decision has consequences, like H
won't answer the question H(<H^>,<H^>). If it is false, you make an
error if you perform logic assuming it never does.

Also, you statement about if H waited long enough for some other copy of
it to make its decision is basically a null set for your design. Since
the H inside will take just as long to make its decision as the H doing
the simulation, to figure out how long it needs to simulate is like
finding the answer to the problem find an X that is greater than X+1,
there is no such number, so their can't be a machine with your type of
algorithm that can simulate long enough to simulate a copy of itself
making the same decision.

Note, this doesn't say that Halting Problem is a bad problem, just that
this particular method doesn't work. It just so happens that we know
that ANY method we come up with won't be able to work, because the job
has been proven to be impossible.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<HJWVI.42$dI3.12@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer03.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
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com>
<5zqVI.10579$kQ4.10540@fx13.iad>
<Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad>
<Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk>
<eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me>
<IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 36
Message-ID: <HJWVI.42$dI3.12@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, 26 Aug 2021 20:55:02 -0400
X-Received-Bytes: 3420
 by: Richard Damon - Fri, 27 Aug 2021 00:55 UTC

On 8/26/21 7:19 PM, olcott wrote:
> On 8/26/2021 6:12 PM, Richard Damon wrote:
>> On 8/26/21 2:10 PM, olcott wrote:
>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>
>>>> And if you don't know exactly how a UTM works, then how do you plan on
>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>> recognize a given sequence of steps as being infinite?
>>>>
>>>> André
>>>>
>>>
>>> A UTM must simulate the code that it is presented with. If this code
>>> writes to its tape the it must literally write to its tape.
>>>
>>
>> Right, but it write the representation of that data, not the data itself.
>>
>> Remember the machine that the UTM is running on, and thus that 'symbol
>> set' of the tape may be very different than the symbol set of the
>> machine that it is simulating, so there is an encoding issue.
>>
>> THere also needs to be an encoding of where the tape is, since the
>> actual tape the UTM is using will be moving to other spots.
>>
>
> All of that merely dodges Ben's mistake.
> You really can't seem to stay focused on the pint at hand.
>

No, YOU miss the important point. If the simulate machine writes a given
symbol onto its simulated tape (like a '1') that doesn't mean the actual
tape got a '1' written on it, and in fact, that tape might not even
allow the symbol '1' to be written. Instead, the UTM translates that
writing of a '1' in the simulated machine into writting a representation
of that '1' in its representation of the tape.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<sg9do3$620$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Date: Thu, 26 Aug 2021 19:05:06 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 48
Message-ID: <sg9do3$620$1@dont-email.me>
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87zgt69xah.fsf@bsb.me.uk> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com>
<5zqVI.10579$kQ4.10540@fx13.iad>
<Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad>
<Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk>
<eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me>
<IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 27 Aug 2021 01:05:08 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="623c4a397b26e2cc1f9b7d202736166b";
logging-data="6208"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/pURIrp2aXnCNZ/WNtsZe0"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:yQEhBm2ajbWq5gPBwKbHkkr8BXk=
In-Reply-To: <HJWVI.42$dI3.12@fx10.iad>
Content-Language: en-US
 by: André G. Isaak - Fri, 27 Aug 2021 01:05 UTC

On 2021-08-26 18:55, Richard Damon wrote:
> On 8/26/21 7:19 PM, olcott wrote:
>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>> On 8/26/21 2:10 PM, olcott wrote:
>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>
>>>>> And if you don't know exactly how a UTM works, then how do you plan on
>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>> recognize a given sequence of steps as being infinite?
>>>>>
>>>>> André
>>>>>
>>>>
>>>> A UTM must simulate the code that it is presented with. If this code
>>>> writes to its tape the it must literally write to its tape.
>>>>
>>>
>>> Right, but it write the representation of that data, not the data itself.
>>>
>>> Remember the machine that the UTM is running on, and thus that 'symbol
>>> set' of the tape may be very different than the symbol set of the
>>> machine that it is simulating, so there is an encoding issue.
>>>
>>> THere also needs to be an encoding of where the tape is, since the
>>> actual tape the UTM is using will be moving to other spots.
>>>
>>
>> All of that merely dodges Ben's mistake.
>> You really can't seem to stay focused on the pint at hand.
>>
>
> No, YOU miss the important point. If the simulate machine writes a given
> symbol onto its simulated tape (like a '1') that doesn't mean the actual
> tape got a '1' written on it, and in fact, that tape might not even
> allow the symbol '1' to be written. Instead, the UTM translates that
> writing of a '1' in the simulated machine into writting a representation
> of that '1' in its representation of the tape.

Also, the 'copy' of the string likely won't even occupy a contiguous
sequence of cells on the tape, so the idea that the UTM makes a literal
'byte-for-byte' copy of the string is doubly-wrong.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!4.us.feeder.erje.net!2.eu.feeder.erje.net!feeder.erje.net!news.uzoreto.com!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 26 Aug 2021 21:48:49 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com> <5zqVI.10579$kQ4.10540@fx13.iad> <Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad> <Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com> <p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me> <0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me> <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com> <%dVVI.4471$o45.2514@fx46.iad> <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad> <sg9do3$620$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Thu, 26 Aug 2021 21:48:47 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <sg9do3$620$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
Lines: 66
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-0HS5THQSRxHNf1fAFzRV8eroS7NkOuHwHiHYWRDJd2Vl2d7+iTKY4FsyxDWD+Qd80YNQuWL0bSPs4qA!turjXVFkLS26CPjIAsrupAxKr9W+h/aYy76+8XOfNMxzuNPGDpwLgNklehLMqbwA7VU5UDcfT2o1!uec=
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: 4532
 by: olcott - Fri, 27 Aug 2021 02:48 UTC

On 8/26/2021 8:05 PM, André G. Isaak wrote:
> On 2021-08-26 18:55, Richard Damon wrote:
>> On 8/26/21 7:19 PM, olcott wrote:
>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>
>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>> plan on
>>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> A UTM must simulate the code that it is presented with. If this code
>>>>> writes to its tape the it must literally write to its tape.
>>>>>
>>>>
>>>> Right, but it write the representation of that data, not the data
>>>> itself.
>>>>
>>>> Remember the machine that the UTM is running on, and thus that 'symbol
>>>> set' of the tape may be very different than the symbol set of the
>>>> machine that it is simulating, so there is an encoding issue.
>>>>
>>>> THere also needs to be an encoding of where the tape is, since the
>>>> actual tape the UTM is using will be moving to other spots.
>>>>
>>>
>>> All of that merely dodges Ben's mistake.
>>> You really can't seem to stay focused on the pint at hand.
>>>
>>
>> No, YOU miss the important point. If the simulate machine writes a given
>> symbol onto its simulated tape (like a '1') that doesn't mean the actual
>> tape got a '1' written on it, and in fact, that tape might not even
>> allow the symbol '1' to be written. Instead, the UTM translates that
>> writing of a '1' in the simulated machine into writting a representation
>> of that '1' in its representation of the tape.
>

That is very dumb.

> Also, the 'copy' of the string likely won't even occupy a contiguous
> sequence of cells on the tape,

None-the-less (everyone keep dodging) Ben was wrong a string copy is a
freaking copy of a freaking string.

> so the idea that the UTM makes a literal
> 'byte-for-byte' copy of the string is doubly-wrong.
>
> André
>
>

If the TM copies the string then the freaking UTM had better simulate
this operation and copy a freaking string.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<634WI.2231$tG6.308@fx39.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<5zqVI.10579$kQ4.10540@fx13.iad>
<Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad>
<Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk>
<eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me>
<IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 88
Message-ID: <634WI.2231$tG6.308@fx39.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, 27 Aug 2021 07:32:17 -0400
X-Received-Bytes: 5285
 by: Richard Damon - Fri, 27 Aug 2021 11:32 UTC

On 8/26/21 10:48 PM, olcott wrote:
> On 8/26/2021 8:05 PM, André G. Isaak wrote:
>> On 2021-08-26 18:55, Richard Damon wrote:
>>> On 8/26/21 7:19 PM, olcott wrote:
>>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>>
>>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>>> plan on
>>>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> A UTM must simulate the code that it is presented with. If this code
>>>>>> writes to its tape the it must literally write to its tape.
>>>>>>
>>>>>
>>>>> Right, but it write the representation of that data, not the data
>>>>> itself.
>>>>>
>>>>> Remember the machine that the UTM is running on, and thus that 'symbol
>>>>> set' of the tape may be very different than the symbol set of the
>>>>> machine that it is simulating, so there is an encoding issue.
>>>>>
>>>>> THere also needs to be an encoding of where the tape is, since the
>>>>> actual tape the UTM is using will be moving to other spots.
>>>>>
>>>>
>>>> All of that merely dodges Ben's mistake.
>>>> You really can't seem to stay focused on the pint at hand.
>>>>
>>>
>>> No, YOU miss the important point. If the simulate machine writes a given
>>> symbol onto its simulated tape (like a '1') that doesn't mean the actual
>>> tape got a '1' written on it, and in fact, that tape might not even
>>> allow the symbol '1' to be written. Instead, the UTM translates that
>>> writing of a '1' in the simulated machine into writting a representation
>>> of that '1' in its representation of the tape.
>>
>
> That is very dumb.

No, it is how it has to work. As I said, the machine the UTM is running
on may well not be able to write that symbol.

It is like when a virtualized program writes a value to location 5, it
may not go into physical memory location 5, but gets mapped to some
other location. The key is that the virtual machine sees it as at
location 5.

In the same way, the simulated machine will see the symbol that it wrote
at that location in its simulated tape. The real tape will do something,
but not necessarily exactly the same thing. It converts the operations
in the simulated machine into representations that happen on the
physical machine.

>
>> Also, the 'copy' of the string likely won't even occupy a contiguous
>> sequence of cells on the tape,
>
> None-the-less (everyone keep dodging) Ben was wrong a string copy is a
> freaking copy of a freaking string.

I think you misunderstood what Ben was saying. It creates a copy in the
simulated tape, which might be something different on the physical tape.

>
>> so the idea that the UTM makes a literal 'byte-for-byte' copy of the
>> string is doubly-wrong.
>>
>> André
>>
>>
>
> If the TM copies the string then the freaking UTM had better simulate
> this operation and copy a freaking string.
>

It will create a simulated copy of the string. That doesn't mean the
actual tape will contain a copy of the actual tape.

The simulated machine will see the copy on its simulated tape.

Maybe you don't even understand how simulators work. Is that why it took
you so long even when you used someone else existing simulator as a base?

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!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: Fri, 27 Aug 2021 09:09:18 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<Ea2dndkCwo0bzbv8nZ2dnUU7-dHNnZ2d@giganews.com> <Z2BVI.1293$F26.792@fx44.iad>
<Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk>
<eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me>
<IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 09:09:18 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <634WI.2231$tG6.308@fx39.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
Lines: 103
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-W0hbwQEZRbwAq1liYwACgee3CQBPdOYs8SgWNGmImIbKZ5z2I9MBEj75YEXWZXvTBG8bD4K50EXEU4f!ydocpaxRlEKs8VbxTeRoRbnj0RlnudVP4u4Jq7jnhioqjWV37P8ytdhE8xXrX4PAkiyp/WKnoRCH!7rY=
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: 6108
 by: olcott - Fri, 27 Aug 2021 14:09 UTC

On 8/27/2021 6:32 AM, Richard Damon wrote:
> On 8/26/21 10:48 PM, olcott wrote:
>> On 8/26/2021 8:05 PM, André G. Isaak wrote:
>>> On 2021-08-26 18:55, Richard Damon wrote:
>>>> On 8/26/21 7:19 PM, olcott wrote:
>>>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>>>> plan on
>>>>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> A UTM must simulate the code that it is presented with. If this code
>>>>>>> writes to its tape the it must literally write to its tape.
>>>>>>>
>>>>>>
>>>>>> Right, but it write the representation of that data, not the data
>>>>>> itself.
>>>>>>
>>>>>> Remember the machine that the UTM is running on, and thus that 'symbol
>>>>>> set' of the tape may be very different than the symbol set of the
>>>>>> machine that it is simulating, so there is an encoding issue.
>>>>>>
>>>>>> THere also needs to be an encoding of where the tape is, since the
>>>>>> actual tape the UTM is using will be moving to other spots.
>>>>>>
>>>>>
>>>>> All of that merely dodges Ben's mistake.
>>>>> You really can't seem to stay focused on the pint at hand.
>>>>>
>>>>
>>>> No, YOU miss the important point. If the simulate machine writes a given
>>>> symbol onto its simulated tape (like a '1') that doesn't mean the actual
>>>> tape got a '1' written on it, and in fact, that tape might not even
>>>> allow the symbol '1' to be written. Instead, the UTM translates that
>>>> writing of a '1' in the simulated machine into writting a representation
>>>> of that '1' in its representation of the tape.
>>>
>>
>> That is very dumb.
>
> No, it is how it has to work.

The UTM is a TM of the same type as the TM that it emulates, assuming
otherwise is ridiculous. Ben is flatly wrong and you are a liar for not
acknowledging this.

> As I said, the machine the UTM is running
> on may well not be able to write that symbol.
>
> It is like when a virtualized program writes a value to location 5, it
> may not go into physical memory location 5, but gets mapped to some
> other location. The key is that the virtual machine sees it as at
> location 5.
>
> In the same way, the simulated machine will see the symbol that it wrote
> at that location in its simulated tape. The real tape will do something,
> but not necessarily exactly the same thing. It converts the operations
> in the simulated machine into representations that happen on the
> physical machine.
>
>>
>>> Also, the 'copy' of the string likely won't even occupy a contiguous
>>> sequence of cells on the tape,
>>
>> None-the-less (everyone keep dodging) Ben was wrong a string copy is a
>> freaking copy of a freaking string.
>
> I think you misunderstood what Ben was saying. It creates a copy in the
> simulated tape, which might be something different on the physical tape.
>
>>
>>> so the idea that the UTM makes a literal 'byte-for-byte' copy of the
>>> string is doubly-wrong.
>>>
>>> André
>>>
>>>
>>
>> If the TM copies the string then the freaking UTM had better simulate
>> this operation and copy a freaking string.
>>
>
> It will create a simulated copy of the string. That doesn't mean the
> actual tape will contain a copy of the actual tape.
>
> The simulated machine will see the copy on its simulated tape.
>
> Maybe you don't even understand how simulators work. Is that why it took
> you so long even when you used someone else existing simulator as a base?
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ conversation has ended? ]

<AZmdnQWlt-U4brX8nZ2dnUU7-LPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 27 Aug 2021 09:16:05 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ conversation has ended? ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <87o89pf5zi.fsf@bsb.me.uk> <R_WdnWjO0dnDlb78nZ2dnUU7-bvNnZ2d@giganews.com> <87k0kce1yk.fsf@bsb.me.uk> <edCdnTY_IvB2N778nZ2dnUU7-WvNnZ2d@giganews.com> <87bl5oc62l.fsf@bsb.me.uk> <INadnSiJbfTFYb78nZ2dnUU7-LPNnZ2d@giganews.com> <87tujfbv4y.fsf@bsb.me.uk> <5bidne_8HrBuqbn8nZ2dnUU7-dfNnZ2d@giganews.com> <87lf4rbksk.fsf@bsb.me.uk> <Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com> <87fsuzaq8t.fsf@bsb.me.uk> <__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com> <87zgt69xah.fsf@bsb.me.uk> <tqadndv0qJ8vOLj8nZ2dnUU7-R_NnZ2d@giganews.com> <1LCdnZZtHK3SK7j8nZ2dnUU7-R_NnZ2d@giganews.com> <87lf4pa56n.fsf@bsb.me.uk> <feudnRmpetF2G7v8nZ2dnUU7-VfNnZ2d@giganews.com> <87czq19wx0.fsf@bsb.me.uk> <Y7adnS3RyacCCbv8nZ2dnUU7-UWdnZ2d@giganews.com> <874kbcaojh.fsf@bsb.me.uk> <CMDVI.3286$nR3.588@fx38.iad> <eISdnXNd1-AYkrr8nZ2dnUU7-eednZ2d@giganews.com> <fdKVI.12$tG6.10@fx39.iad> <Oa6dnSl31ap5E7r8nZ2dnUU7-bPNnZ2d@giganews.com> <zuWVI.1055$2Q_3.854@fx35.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 09:16:04 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <zuWVI.1055$2Q_3.854@fx35.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <AZmdnQWlt-U4brX8nZ2dnUU7-LPNnZ2d@giganews.com>
Lines: 112
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kWon704qt8PUpaNd/2DhLgRWpr4r5bXMaFFn5RyGDZ/HOQ3WMTrrJiek7/VHWb/CgEQMp7AjTl0kNUm!3v64NWOgGFaXhJ1zVXLEsS6f2zDq2m93Y1pStk+vpHDfgx2lve06XmfWUCFpAH6cEYGnR6ccYqLr!77c=
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: 6506
 by: olcott - Fri, 27 Aug 2021 14:16 UTC

On 8/26/2021 7:38 PM, Richard Damon wrote:
> On 8/26/21 8:53 AM, olcott wrote:
>> On 8/26/2021 5:41 AM, Richard Damon wrote:
>>> On 8/25/21 11:50 PM, olcott wrote:
>>>> On 8/25/2021 10:21 PM, Richard Damon wrote:
>>>>> On 8/25/21 11:10 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>> Too disingenuous to continue.
>>>>>>
>>>>>> Excellent!  Mind you, you've said you won't talk go to me many times
>>>>>> before and I always end up disappointed.
>>>>>>
>>>>>
>>>>> Yes, me too. It is clear that when people clearly point out his
>>>>> mistakes, his brain starts to go crazy and he finds it irresistible to
>>>>> lash out and try to muddy the air with some illogic to try and hide the
>>>>> clear rebuttal.
>>>>>
>>>>> I think he hopes that the thread will go off some other direction and
>>>>> the clear rebuttal will be forgotten.
>>>>>
>>>>> THAT is why he calls them 'dishonest dodges', he thinks if he says that
>>>>> enough some people might beleive it and not look at them.
>>>>>
>>>>
>>>> This is the crux of my whole proof try and refute it without changing
>>>> the subject or talking in circles:
>>>>
>>>> Simulating Halt Decider Theorem (Olcott 2020):
>>>> A simulating halt decider correctly decides that any input that never
>>>> halts unless the simulating halt decider aborts its simulation of this
>>>> input is an input that never halts.
>>>>
>>>
>>> Easy, Fundamental Definitions (do you disagree with any of these):
>>>
>>> The Definition of a Computation: The act of performing a Step by Step
>>> Algorithm on an input data to get an answer. The Algorithm needs to
>>> precisely state exactly what operations to perform and the input needs
>>> to specify all the variable data for the caluclation.
>>>
>>> Since a Computation fully specifies what is done and what it is done on,
>>> every time you run a given computation on the same data you will get the
>>> same answer.
>>>
>>> The Definition of A Halting Computation is CDomputatiion that reaches a
>>> halting state in a finite numb4r of steps. A Non-Halting one is one that
>>> never reaches a Halting state for ANY finite number of Steps.
>>>
>>> The Definition of a Halt Decider: A Computation that, when given as an
>>> input the representation of a Computation, is able to correctly indicate
>>> if that Computation is Halting or Non-Halting.
>>>
>>> Thus the right answer isn't based on a partial simulation performed by
>>> the decider, but on what the actual machine does.
>>>
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>>   if (H(x, x))
>>     HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>   Output("Input_Halts = ", H1((u32)P, (u32)P));
>> }
>>
>> H1 determines that its input halts on its input on the basis that H
>> determines that its input never halts.
>
> Yes H THINKS its input never halts, but since the input to H is the
> exact same input as to H1, the machine it represents is the same, so its
> behavior MUST be the same.
>
> Think about what you are trying to claim.
>

I don't have to think about it. H1 does correctly decide that P halts on
the basis that H correctly decides that its input never halts.

H1 has identical machine code and inputs to H.
It is the execution order that makes the difference in the results.

H1 can see all of the code that it simulates, H can see all of the code
that its simulates, H1 cannot see any of the code that H simulates.

> THere is a single question, what is the behavior of the machine P(P)?
>
> You ask this of two different deciders.
>
> They give different answers, but you claim they both are correct?
>
> Remember, the question ISN'T will machine X simulate the machine to a
> halt state, the only true actual Halting Question is what is the
> behavior of the machine that the input represents? Is it halting or not.
>
> THAT IS THE DEFINITION.
>
> It CAN'T be different for different deciders, as the question isn't
> about the decider, it is about the machine that the input represents.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<ko2dnV8MlJyYa7X8nZ2dnUU78cHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!border2.nntp.ams1.giganews.com!nntp.giganews.com!buffer2.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 27 Aug 2021 09:26:13 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<Mf2dnamm9d978bn8nZ2dnUU7-cHNnZ2d@giganews.com> <87fsuzaq8t.fsf@bsb.me.uk>
<__WdneskYvGLiLj8nZ2dnUU7-U3NnZ2d@giganews.com> <87zgt69xah.fsf@bsb.me.uk>
<pc6dnd7lf6NfI7j8nZ2dnUU7-fXNnZ2d@giganews.com> <87r1eha6x8.fsf@bsb.me.uk>
<yK2dnZkA2Nsu5Lv8nZ2dnUU7-THNnZ2d@giganews.com> <_8BVI.106$GD7.95@fx23.iad>
<FaydnfJTMNyofrv8nZ2dnUU7-e3NnZ2d@giganews.com> <i7CVI.13$jl2.7@fx34.iad>
<5Y6dndhJqqgGcrv8nZ2dnUU7-RWdnZ2d@giganews.com> <ihCVI.186$2B4.3@fx04.iad>
<CeidnS_08apsaLv8nZ2dnUU7-RmdnZ2d@giganews.com> <sg6ss9$o8n$1@dont-email.me>
<SZ-dncSHQLR3Z7v8nZ2dnUU7-W2dnZ2d@giganews.com> <VdDVI.486$lC6.43@fx41.iad>
<LfednRsEJtD1mbr8nZ2dnUU7-bHNnZ2d@giganews.com>
<WIDVI.5960$Kv2.3004@fx47.iad>
<eISdnXBd1-CTkrr8nZ2dnUU7-eednZ2d@giganews.com> <XgKVI.13$tG6.4@fx39.iad>
<eeydndtCipmXDbr8nZ2dnUU7-YfNnZ2d@giganews.com>
<biVVI.4472$o45.2372@fx46.iad>
<e5qdne9vgZtEvLX8nZ2dnUU7-WednZ2d@giganews.com>
<OGWVI.12677$Kv2.11978@fx47.iad>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 09:26:12 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <OGWVI.12677$Kv2.11978@fx47.iad>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <ko2dnV8MlJyYa7X8nZ2dnUU78cHNnZ2d@giganews.com>
Lines: 153
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-d6fhHSKvQAQ0GAT6U6pC8aVUQnLMuzso7uXJbC73O3AiTreMoqlsf1vt0AkUiJRhbqBS0AHMYWq/xjh!yj9QdxepzhaqJi/KI9/uuS2bDKjYppPFJ9lJeHHSTn9YyDy5t7myaAEaFR5muUkjtqd37MZ1kizL!MYQ=
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: 8306
 by: olcott - Fri, 27 Aug 2021 14:26 UTC

On 8/26/2021 7:51 PM, Richard Damon wrote:
> On 8/26/21 7:20 PM, olcott wrote:
>> On 8/26/2021 6:17 PM, Richard Damon wrote:
>>> On 8/26/21 8:58 AM, olcott wrote:
>>>> On 8/26/2021 5:45 AM, Richard Damon wrote:
>>>>> On 8/25/21 11:48 PM, olcott wrote:
>>>>>> On 8/25/2021 10:17 PM, Richard Damon wrote:
>>>>>>> On 8/25/21 11:03 PM, olcott wrote:
>>>>>>>> On 8/25/2021 9:44 PM, Richard Damon wrote:
>>>>>>>>> On 8/25/21 10:22 PM, olcott wrote:
>>>>>>>>>> On 8/25/2021 9:04 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/25/21 10:01 PM, olcott wrote:
>>>>>>>>>>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>>>>>>>>>>> H(<H^>,<H^>)
>>>>>>>>>>>>>>> says non-halting it was wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That was your last chance.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You admit defeat?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I acknowledge that you are an incorrigible jackass.
>>>>>>>>>>>> The review process moves to phase two.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> What does that mean? You going to write the paper to submit to
>>>>>>>>>>> get
>>>>>>>>>>> your
>>>>>>>>>>> rejection?
>>>>>>>>>>>
>>>>>>>>>>> You have yet to show anywhere whre my basic objections are
>>>>>>>>>>> incorrect.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You know full well that your "objections" are pure drivel.
>>>>>>>>>
>>>>>>>>> No, I, and everyone else who is reading this will see that what
>>>>>>>>> I say
>>>>>>>>> makes sense.
>>>>>>>>>
>>>>>>>>> YOUR statements are the 'pure drivel'.
>>>>>>>>>
>>>>>>>>> Please note that basically no one belives your statements and
>>>>>>>>> everyone
>>>>>>>>> thinks you are wrong. While it is possible that you have discovered
>>>>>>>>> some
>>>>>>>>> hidden secret, it is very unlikely. One key thing to ask yourself,
>>>>>>>>> what
>>>>>>>>> grounds do I have to actually expect that I could come up with some
>>>>>>>>> insite like that that no one else beleives.
>>>>>>>> Because of this my work is not getting an honest review. It is
>>>>>>>> obvious
>>>>>>>> that my work is not getting an honest review to anyone knowing the
>>>>>>>> material very well that all of the "rebuttals" simply dodge directly
>>>>>>>> assessing my points and change to subject to some other points.
>>>>>>>>
>>>>>>>
>>>>>>> No, it HAS gotten an Honest review, and you just don't want to accept
>>>>>>> it, because it shows how BAD your logic is.
>>>>>>>
>>>>>>
>>>>>> You cannot correctly point to any actual mistake in the essence of my
>>>>>> proof. All you can do is talk in circles.
>>>>>>
>>>>>>
>>>>>
>>>>> You mean like the false assumption that H makes that the copy of H that
>>>>> it is simulating will NEVER abort its simulation, when it is clear
>>>>> that,
>>>>> at least if H is a computation, that it will as another identical copy
>>>>> of the computation does.
>>>>>
>>>>
>>>> It is a verified fact that if H waits for some other H to abort the
>>>> simulation that every H waits for some other H to abort the simulation
>>>> and the simulation is never aborted because every H has the exact same
>>>> code.
>>>
>>> Yes, if you change EVERY H
>>
>> H is required to be a single machine or the HP proof is not refuted.
>>
>>
>
> Yes, H is *A* machine, so it has a SPECIFIC definition, SPECIFIED BEFORE
> YOU GET INTO THE PROOF.
>

The key detail that everyone left out that was unspecified because no
one else ever thought it all the way through is what happens when H is a
simulating halt decider.

> Thus, every time YOU talk about a change to H, you just broke the rules
> of the proof and have to start over.
>

Bullshit is was never specified that H is not a simulating halt decider.

> When you posit questions about if H ..., you are outside the proof. Any
> of your if H ... must be a factual Truth Bearer (or is illogical).
>
> If H doesn't abort the simulation, well that statement is either TRUE,
> or it is FALSE. IF it is True, that decision has consequences, like H
> won't answer the question H(<H^>,<H^>). If it is false, you make an
> error if you perform logic assuming it never does.
>

We can see that a hypothetical H that never aborts its simulation never
halts because its input never halts, therefore H is correct to abort its
simulation and report that its input never halts.

> Also, you statement about if H waited long enough for some other copy of
> it to make its decision is basically a null set for your design. Since
> the H inside will take just as long to make its decision as the H doing
> the simulation, to figure out how long it needs to simulate is like
> finding the answer to the problem find an X that is greater than X+1,
> there is no such number, so their can't be a machine with your type of
> algorithm that can simulate long enough to simulate a copy of itself
> making the same decision.
>

This is the key part that must be beyond your intellectual capacity.

Not at all. We can see that this infinite recursion criteria is met:

Infinite recursion detection criteria:
If the execution trace of function X() called by function Y() shows:
(1) Function X() is called twice in sequence from the same machine
address of Y().
(2) With the same parameters to X().
(3) With no conditional branch or indexed jump instructions in Y().
(4) With no function call returns from X().
then the function call from Y() to X() is infinitely recursive.

and on the basis abort the simulation of the input.

> Note, this doesn't say that Halting Problem is a bad problem, just that
> this particular method doesn't work. It just so happens that we know
> that ANY method we come up with won't be able to work, because the job
> has been proven to be impossible.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<sgasok$ssl$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!weretis.net!feeder8.news.weretis.net!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Date: Fri, 27 Aug 2021 08:27:31 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 92
Message-ID: <sgasok$ssl$1@dont-email.me>
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<Z2BVI.1293$F26.792@fx44.iad> <Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com>
<87y28o998g.fsf@bsb.me.uk> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com>
<sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com>
<sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com>
<sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com>
<sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 27 Aug 2021 14:27:33 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="623c4a397b26e2cc1f9b7d202736166b";
logging-data="29589"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/oL3mgjE1tcCC5RkbOqThN"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:t9KCnRF8YyrkUpPk0Rq1kZcDFN0=
In-Reply-To: <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 27 Aug 2021 14:27 UTC

On 2021-08-27 08:09, olcott wrote:
> On 8/27/2021 6:32 AM, Richard Damon wrote:
>> On 8/26/21 10:48 PM, olcott wrote:
>>> On 8/26/2021 8:05 PM, André G. Isaak wrote:
>>>> On 2021-08-26 18:55, Richard Damon wrote:
>>>>> On 8/26/21 7:19 PM, olcott wrote:
>>>>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>>>>
>>>>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>>>>> plan on
>>>>>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> A UTM must simulate the code that it is presented with. If this
>>>>>>>> code
>>>>>>>> writes to its tape the it must literally write to its tape.
>>>>>>>>
>>>>>>>
>>>>>>> Right, but it write the representation of that data, not the data
>>>>>>> itself.
>>>>>>>
>>>>>>> Remember the machine that the UTM is running on, and thus that
>>>>>>> 'symbol
>>>>>>> set' of the tape may be very different than the symbol set of the
>>>>>>> machine that it is simulating, so there is an encoding issue.
>>>>>>>
>>>>>>> THere also needs to be an encoding of where the tape is, since the
>>>>>>> actual tape the UTM is using will be moving to other spots.
>>>>>>>
>>>>>>
>>>>>> All of that merely dodges Ben's mistake.
>>>>>> You really can't seem to stay focused on the pint at hand.
>>>>>>
>>>>>
>>>>> No, YOU miss the important point. If the simulate machine writes a
>>>>> given
>>>>> symbol onto its simulated tape (like a '1') that doesn't mean the
>>>>> actual
>>>>> tape got a '1' written on it, and in fact, that tape might not even
>>>>> allow the symbol '1' to be written. Instead, the UTM translates that
>>>>> writing of a '1' in the simulated machine into writting a
>>>>> representation
>>>>> of that '1' in its representation of the tape.
>>>>
>>>
>>> That is very dumb.
>>
>> No, it is how it has to work.
>
> The UTM is a TM of the same type as the TM that it emulates, assuming
> otherwise is ridiculous. Ben is flatly wrong and you are a liar for not
> acknowledging this.

You're really not doing yourself any favours here.

Ben pointed out that the description you gave was not an accurate
description of what was going on given how UTMs really work. You've
latched onto a rather absurd interpretation of what he is saying and are
refusing to try to understand what he is *actually* saying which is
something far more nuanced than your absurd interpretation, and this
seems to be a general pattern that you have -- when people try to
correct a misconception you have or some terminological error you don't
try to appreciate subtle distinctions which they are trying to draw to
your attention and instead come up with some more ridiculous
interpretation of what is being said and then steadfastly hold onto that
interpretation.

You claim that you want to learn how to express yourself correctly so
people will take your work seriously and Ben is trying to draw your
attention to the fact that you are not expressing yourself in a way that
is strictly accurate, but you're actively resisting trying to learn from
what he is saying.

I gave you a link to a paper which describes how UTMs work. If you
actually read through that paper and then reread this thread maybe you
will realize the point that people are trying to make.

If you simply keep insisting that Ben is wrong and you are right and
that everyone else are liars you're never going to learn to express
yourself in a way that will be taken seriously which you claim is one of
your goals.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 27 Aug 2021 10:11:38 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com> <p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me> <0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me> <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com> <%dVVI.4471$o45.2514@fx46.iad> <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad> <sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com> <634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com> <sgasok$ssl$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 10:11:37 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <sgasok$ssl$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
Lines: 117
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gzo8QeXXXCrf4qBY2tM0aubfIWtNU5NhYMwsh9rODn5sbHAdjQsQMvVvY3UD85h8z9Rxx75UT9Lh3EX!0+iX6Gb8rDyZQtt34Cxo0YKxwPGTN6CxCxxzPkC9F6jUYFh04YDQdYLJXyBozccWGz+XdFOfxr/m!kHY=
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: 7039
 by: olcott - Fri, 27 Aug 2021 15:11 UTC

On 8/27/2021 9:27 AM, André G. Isaak wrote:
> On 2021-08-27 08:09, olcott wrote:
>> On 8/27/2021 6:32 AM, Richard Damon wrote:
>>> On 8/26/21 10:48 PM, olcott wrote:
>>>> On 8/26/2021 8:05 PM, André G. Isaak wrote:
>>>>> On 2021-08-26 18:55, Richard Damon wrote:
>>>>>> On 8/26/21 7:19 PM, olcott wrote:
>>>>>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>>>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>>>>>
>>>>>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>>>>>> plan on
>>>>>>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> A UTM must simulate the code that it is presented with. If this
>>>>>>>>> code
>>>>>>>>> writes to its tape the it must literally write to its tape.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, but it write the representation of that data, not the data
>>>>>>>> itself.
>>>>>>>>
>>>>>>>> Remember the machine that the UTM is running on, and thus that
>>>>>>>> 'symbol
>>>>>>>> set' of the tape may be very different than the symbol set of the
>>>>>>>> machine that it is simulating, so there is an encoding issue.
>>>>>>>>
>>>>>>>> THere also needs to be an encoding of where the tape is, since the
>>>>>>>> actual tape the UTM is using will be moving to other spots.
>>>>>>>>
>>>>>>>
>>>>>>> All of that merely dodges Ben's mistake.
>>>>>>> You really can't seem to stay focused on the pint at hand.
>>>>>>>
>>>>>>
>>>>>> No, YOU miss the important point. If the simulate machine writes a
>>>>>> given
>>>>>> symbol onto its simulated tape (like a '1') that doesn't mean the
>>>>>> actual
>>>>>> tape got a '1' written on it, and in fact, that tape might not even
>>>>>> allow the symbol '1' to be written. Instead, the UTM translates that
>>>>>> writing of a '1' in the simulated machine into writting a
>>>>>> representation
>>>>>> of that '1' in its representation of the tape.
>>>>>
>>>>
>>>> That is very dumb.
>>>
>>> No, it is how it has to work.
>>
>> The UTM is a TM of the same type as the TM that it emulates, assuming
>> otherwise is ridiculous. Ben is flatly wrong and you are a liar for
>> not acknowledging this.
>
> You're really not doing yourself any favours here.
>
> Ben pointed out that the description you gave was not an accurate
> description of what was going on given how UTMs really work.

A UTM is essentially a conventional programming language interpreter.
This merely adds another layer of overhead on top of what would
otherwise be simply direct execution. If the TM is required to copy a
string then the interpretation of the source code of this TM must also
copy a string.

> You've
> latched onto a rather absurd interpretation of what he is saying and are
> refusing to try to understand what he is *actually* saying which is
> something far more nuanced than your absurd interpretation, and this

He is saying the the UTM and the TM cold be defined on the basis of
incompatible specification of the defined of a TM. One might use bits as
its basis data type and the other might use bytes.

> seems to be a general pattern that you have -- when people try to
> correct a misconception you have or some terminological error you don't
> try to appreciate subtle distinctions which they are trying to draw to
> your attention and instead come up with some more ridiculous
> interpretation of what is being said and then steadfastly hold onto that
> interpretation.
>
> You claim that you want to learn how to express yourself correctly so
> people will take your work seriously and Ben is trying to draw your
> attention to the fact that you are not expressing yourself in a way that
> is strictly accurate, but you're actively resisting trying to learn from
> what he is saying.
>
> I gave you a link to a paper which describes how UTMs work. If you
> actually read through that paper and then reread this thread maybe you
> will realize the point that people are trying to make.
>
> If you simply keep insisting that Ben is wrong and you are right and
> that everyone else are liars you're never going to learn to express
> yourself in a way that will be taken seriously which you claim is one of
> your goals.
>
> André
>

How can the UTM simulation of a machine that copies a string not perform
the functional equivalent of copying a string and still be an accurate
simulation of this TM?

That is like asking:
How can your own pet dog be a type of office building?

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:1a07:: with SMTP id fh7mr10392260qvb.41.1630077646784; Fri, 27 Aug 2021 08:20:46 -0700 (PDT)
X-Received: by 2002:a25:1e03:: with SMTP id e3mr5562480ybe.459.1630077646501; Fri, 27 Aug 2021 08:20:46 -0700 (PDT)
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.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, 27 Aug 2021 08:20:46 -0700 (PDT)
In-Reply-To: <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:7082:bb6b:29c0:5d4a; posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:7082:bb6b:29c0:5d4a
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <Y7udnRjYJLheQrv8nZ2dnUU7-avNnZ2d@giganews.com> <87y28o998g.fsf@bsb.me.uk> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com> <p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me> <0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me> <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com> <%dVVI.4471$o45.2514@fx46.iad> <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad> <sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com> <634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com> <sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Fri, 27 Aug 2021 15:20:46 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 13
 by: Malcolm McLean - Fri, 27 Aug 2021 15:20 UTC

On Friday, 27 August 2021 at 16:11:45 UTC+1, olcott wrote:
>
> How can the UTM simulation of a machine that copies a string not perform
> the functional equivalent of copying a string and still be an accurate
> simulation of this TM?
>
If the machine simply copies the input string, then the UTM simulation must
place a copy of the input on the tape before it terminates. However the intermediate
steps don't have to be particularly close, you probably won't see the input string
appear in a recognisable form until the last few steps.
If the machine never terminates, then the UTM also never terminates. Whilst you
might see copies of the input string concatenated on the tape, as the UTM runs,
this isn't guaranteed, and certainly some of the tape will be in a complex configuration
that the UTM uses to keep track of the emulated machine's state.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<sgb20e$ojg$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Date: Fri, 27 Aug 2021 09:57:00 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 151
Message-ID: <sgb20e$ojg$1@dont-email.me>
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<87y28o998g.fsf@bsb.me.uk> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com>
<sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com>
<sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com>
<sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com>
<sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
<sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 27 Aug 2021 15:57:02 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="623c4a397b26e2cc1f9b7d202736166b";
logging-data="25200"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19zv7FL43f2qrnlOJAWUqrQ"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:8/JBQe8ElDiVPl1mD7jrfaPWhyA=
In-Reply-To: <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 27 Aug 2021 15:57 UTC

On 2021-08-27 09:11, olcott wrote:
> On 8/27/2021 9:27 AM, André G. Isaak wrote:
>> On 2021-08-27 08:09, olcott wrote:
>>> On 8/27/2021 6:32 AM, Richard Damon wrote:
>>>> On 8/26/21 10:48 PM, olcott wrote:
>>>>> On 8/26/2021 8:05 PM, André G. Isaak wrote:
>>>>>> On 2021-08-26 18:55, Richard Damon wrote:
>>>>>>> On 8/26/21 7:19 PM, olcott wrote:
>>>>>>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>>>>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>>>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>>>>>>
>>>>>>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>>>>>>> plan on
>>>>>>>>>>> establishing that a 'simulating halt decider' based on a UTM can
>>>>>>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A UTM must simulate the code that it is presented with. If
>>>>>>>>>> this code
>>>>>>>>>> writes to its tape the it must literally write to its tape.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, but it write the representation of that data, not the data
>>>>>>>>> itself.
>>>>>>>>>
>>>>>>>>> Remember the machine that the UTM is running on, and thus that
>>>>>>>>> 'symbol
>>>>>>>>> set' of the tape may be very different than the symbol set of the
>>>>>>>>> machine that it is simulating, so there is an encoding issue.
>>>>>>>>>
>>>>>>>>> THere also needs to be an encoding of where the tape is, since the
>>>>>>>>> actual tape the UTM is using will be moving to other spots.
>>>>>>>>>
>>>>>>>>
>>>>>>>> All of that merely dodges Ben's mistake.
>>>>>>>> You really can't seem to stay focused on the pint at hand.
>>>>>>>>
>>>>>>>
>>>>>>> No, YOU miss the important point. If the simulate machine writes
>>>>>>> a given
>>>>>>> symbol onto its simulated tape (like a '1') that doesn't mean the
>>>>>>> actual
>>>>>>> tape got a '1' written on it, and in fact, that tape might not even
>>>>>>> allow the symbol '1' to be written. Instead, the UTM translates that
>>>>>>> writing of a '1' in the simulated machine into writting a
>>>>>>> representation
>>>>>>> of that '1' in its representation of the tape.
>>>>>>
>>>>>
>>>>> That is very dumb.
>>>>
>>>> No, it is how it has to work.
>>>
>>> The UTM is a TM of the same type as the TM that it emulates, assuming
>>> otherwise is ridiculous. Ben is flatly wrong and you are a liar for
>>> not acknowledging this.
>>
>> You're really not doing yourself any favours here.
>>
>> Ben pointed out that the description you gave was not an accurate
>> description of what was going on given how UTMs really work.
>
> A UTM is essentially a conventional programming language interpreter.

It really isn't. You need to learn about TMs and to stop thinking of
them in terms of programming languages or "software engineering". They
are a very different model from the things you are familiar with.

> This merely adds another layer of overhead on top of what would
> otherwise be simply direct execution. If the TM is required to copy a
> string then the interpretation of the source code of this TM must also
> copy a string.

TMs don't have "source code". We're not dealing with programming
languages here. If a UTM is emulating a TM which makes a copy of a
string, it must write some representation to the tape, but Ben's point
was that this won't be a *literal* copy of that string. It may be
something which looks entirely different.

>> You've latched onto a rather absurd interpretation of what he is
>> saying and are refusing to try to understand what he is *actually*
>> saying which is something far more nuanced than your absurd
>> interpretation, and this
>
> He is saying the the UTM and the TM cold be defined on the basis of
> incompatible specification of the defined of a TM. One might use bits as
> its basis data type and the other might use bytes.

TMs don't use bits or bytes. Again, you need to stop thinking of TMs in
terms of programming languages or existing computer hardware. They are
mathematical abstractions unrelated to either of these things.

The point is that a UTM is a TM which accepts a description of *any* TM
as part of its input string. The set of all possible TMs includes TMs
which use entirely different alphabets and a UTM must be able to deal
with *all* of these. The TM being emulated may have a smaller or larger
alphabet than the UTM makes use of.

If you read the paper to which I gave you a link, it will explain how
this is accomplished and give examples of actual, fully specified UTMs.
It will clear up many of your misconceptions and then you can reread
this thread and you might actually grasp what is being said. If you
don't understand how UTMs work (and you don't), you shouldn't be telling
people they are wrong when they try to explain to you how UTMs actually
work. It just makes you look foolish.

>> seems to be a general pattern that you have -- when people try to
>> correct a misconception you have or some terminological error you
>> don't try to appreciate subtle distinctions which they are trying to
>> draw to your attention and instead come up with some more ridiculous
>> interpretation of what is being said and then steadfastly hold onto
>> that interpretation.
>>
>> You claim that you want to learn how to express yourself correctly so
>> people will take your work seriously and Ben is trying to draw your
>> attention to the fact that you are not expressing yourself in a way
>> that is strictly accurate, but you're actively resisting trying to
>> learn from what he is saying.
>>
>> I gave you a link to a paper which describes how UTMs work. If you
>> actually read through that paper and then reread this thread maybe you
>> will realize the point that people are trying to make.
>>
>> If you simply keep insisting that Ben is wrong and you are right and
>> that everyone else are liars you're never going to learn to express
>> yourself in a way that will be taken seriously which you claim is one
>> of your goals.
>>
>> André
>>
>
> How can the UTM simulation of a machine that copies a string not perform
> the functional equivalent of copying a string and still be an accurate
> simulation of this TM?

Ben never made any claims that it didn't perform some operation which
could be construed as the functional equivalent of copying a string. He
claimed that there was no *literal* copying involved except in the first
instance. You've latched onto this strange interpretation that he meant
that nothing actually gets done in subsequent instances. That wasn't his
claim. His claim that what was going on in subsequent instances was not
actually as you were presenting it.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ intentional bias == Liar ]

<fpqdnUlVMav3lrT8nZ2dnUU7-KHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 27 Aug 2021 10:57:30 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ intentional bias == Liar ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com> <p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me> <0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me> <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com> <%dVVI.4471$o45.2514@fx46.iad> <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad> <sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com> <634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com> <sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com> <3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 10:57:30 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <fpqdnUlVMav3lrT8nZ2dnUU7-KHNnZ2d@giganews.com>
Lines: 56
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wkXcm6XkDmJlwdj3K0ZHF+65+FIf/+nnLxSotXEWFPSCgCbsaTpp4unrda/4fw/AsaDhbRhQ6nGwQyQ!GO21eu2ESkj8/aslMMKwu2oib/h56pyC6rQ91b9YFj6CsMWvLTon8RFK3rWah59Dz1bcLLfieO/R!wBw=
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: 4685
 by: olcott - Fri, 27 Aug 2021 15:57 UTC

On 8/27/2021 10:20 AM, Malcolm McLean wrote:
> On Friday, 27 August 2021 at 16:11:45 UTC+1, olcott wrote:
>>
>> How can the UTM simulation of a machine that copies a string not perform
>> the functional equivalent of copying a string and still be an accurate
>> simulation of this TM?
>>
> If the machine simply copies the input string, then the UTM simulation must
> place a copy of the input on the tape before it terminates.

Because Ben said this is not true Ben is wrong.

> However the intermediate
> steps don't have to be particularly close, you probably won't see the input string
> appear in a recognisable form until the last few steps.

Merely the lower level details of the UTM simulation process. At the
higher level of abstraction of the simulated machine when it copies a
string the string is simply copied.

> If the machine never terminates, then the UTM also never terminates. Whilst you
> might see copies of the input string concatenated on the tape, as the UTM runs,
> this isn't guaranteed, and certainly some of the tape will be in a complex configuration
> that the UTM uses to keep track of the emulated machine's state.
>

When we define Ĵ to be exactly like Ĥ except that it has a UTM at Ĵ.qx
instead of a simulating halt decider then we can see that Ĵ applied to
⟨Ĵ⟩ never halts.

Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then simulates this input Ĵ1 with its
input ⟨Ĵ2⟩
which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then simulates this input Ĵ2 with
its input ⟨Ĵ3⟩
which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then simulates this input Ĵ3 with
its input ⟨Ĵ4⟩ ...

In this case we are guaranteed that there is an increasing number of
copies of ⟨Ĵ⟩ on the tape.

It is really not that hard, that Ben does not acknowledge this seems to
be a case where he is "grasping at straws" to artificially contrive at
least some rebuttal of some minor point as if rebuttal is his only
purpose and he sacrifices an actual honest dialogue for this pure
rebuttal purpose.

I think that it is reasonable to call people that have a sole purpose of
rebuttal at the expense of an honest dialogue liars. An intentional bias
is an intentional divergence from truth whether or not this intentional
bias results in any actual falsehoods.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<N_-dne9M3cTwjbT8nZ2dnUU7-bnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 27 Aug 2021 11:18:53 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com> <eISdnXZd1-Dak7r8nZ2dnUU7-efNnZ2d@giganews.com> <sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com> <p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me> <0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me> <CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com> <%dVVI.4471$o45.2514@fx46.iad> <e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad> <sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com> <634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com> <sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com> <sgb20e$ojg$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 11:18:52 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <sgb20e$ojg$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <N_-dne9M3cTwjbT8nZ2dnUU7-bnNnZ2d@giganews.com>
Lines: 193
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TPuuOEnEysGA4vtXip8SXcLbDDLr8LXpbkZ8CfisiFvgx9PWa2eJNXhQInffrMO++tl1mHRsDFt+FNf!iU6oafzf1e9g/Qc1zh4wEDTumHc91dMC87MXDyta9gQYZy4o12GGTqOBhUZ+oeIfN8/E85pbo0LU!qPs=
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: 10685
 by: olcott - Fri, 27 Aug 2021 16:18 UTC

On 8/27/2021 10:57 AM, André G. Isaak wrote:
> On 2021-08-27 09:11, olcott wrote:
>> On 8/27/2021 9:27 AM, André G. Isaak wrote:
>>> On 2021-08-27 08:09, olcott wrote:
>>>> On 8/27/2021 6:32 AM, Richard Damon wrote:
>>>>> On 8/26/21 10:48 PM, olcott wrote:
>>>>>> On 8/26/2021 8:05 PM, André G. Isaak wrote:
>>>>>>> On 2021-08-26 18:55, Richard Damon wrote:
>>>>>>>> On 8/26/21 7:19 PM, olcott wrote:
>>>>>>>>> On 8/26/2021 6:12 PM, Richard Damon wrote:
>>>>>>>>>> On 8/26/21 2:10 PM, olcott wrote:
>>>>>>>>>>> On 8/26/2021 1:03 PM, André G. Isaak wrote:
>>>>>>>>>>
>>>>>>>>>>>> And if you don't know exactly how a UTM works, then how do you
>>>>>>>>>>>> plan on
>>>>>>>>>>>> establishing that a 'simulating halt decider' based on a UTM
>>>>>>>>>>>> can
>>>>>>>>>>>> recognize a given sequence of steps as being infinite?
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> A UTM must simulate the code that it is presented with. If
>>>>>>>>>>> this code
>>>>>>>>>>> writes to its tape the it must literally write to its tape.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, but it write the representation of that data, not the data
>>>>>>>>>> itself.
>>>>>>>>>>
>>>>>>>>>> Remember the machine that the UTM is running on, and thus that
>>>>>>>>>> 'symbol
>>>>>>>>>> set' of the tape may be very different than the symbol set of the
>>>>>>>>>> machine that it is simulating, so there is an encoding issue.
>>>>>>>>>>
>>>>>>>>>> THere also needs to be an encoding of where the tape is, since
>>>>>>>>>> the
>>>>>>>>>> actual tape the UTM is using will be moving to other spots.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> All of that merely dodges Ben's mistake.
>>>>>>>>> You really can't seem to stay focused on the pint at hand.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, YOU miss the important point. If the simulate machine writes
>>>>>>>> a given
>>>>>>>> symbol onto its simulated tape (like a '1') that doesn't mean
>>>>>>>> the actual
>>>>>>>> tape got a '1' written on it, and in fact, that tape might not even
>>>>>>>> allow the symbol '1' to be written. Instead, the UTM translates
>>>>>>>> that
>>>>>>>> writing of a '1' in the simulated machine into writting a
>>>>>>>> representation
>>>>>>>> of that '1' in its representation of the tape.
>>>>>>>
>>>>>>
>>>>>> That is very dumb.
>>>>>
>>>>> No, it is how it has to work.
>>>>
>>>> The UTM is a TM of the same type as the TM that it emulates,
>>>> assuming otherwise is ridiculous. Ben is flatly wrong and you are a
>>>> liar for not acknowledging this.
>>>
>>> You're really not doing yourself any favours here.
>>>
>>> Ben pointed out that the description you gave was not an accurate
>>> description of what was going on given how UTMs really work.
>>
>> A UTM is essentially a conventional programming language interpreter.
>
> It really isn't. You need to learn about TMs and to stop thinking of
> them in terms of programming languages or "software engineering". They
> are a very different model from the things you are familiar with.
>
>> This merely adds another layer of overhead on top of what would
>> otherwise be simply direct execution. If the TM is required to copy a
>> string then the interpretation of the source code of this TM must also
>> copy a string.
>
> TMs don't have "source code".

The machine description of a TM that is simulated on a UTM is for all
practical purposes source-code that is interpreted. There are no
material differences.

> We're not dealing with programming
> languages here. If a UTM is emulating a TM which makes a copy of a
> string, it must write some representation to the tape, but Ben's point
> was that this won't be a *literal* copy of that string. It may be
> something which looks entirely different.
>
>>> You've latched onto a rather absurd interpretation of what he is
>>> saying and are refusing to try to understand what he is *actually*
>>> saying which is something far more nuanced than your absurd
>>> interpretation, and this
>>
>> He is saying the the UTM and the TM cold be defined on the basis of
>> incompatible specification of the defined of a TM. One might use bits
>> as its basis data type and the other might use bytes.
>
> TMs don't use bits or bytes. Again, you need to stop thinking of TMs in
> terms of programming languages or existing computer hardware. They are
> mathematical abstractions unrelated to either of these things.
>
So when a TM writes to its tape what it is writing?
Conventionally it is writing a bit.

> The point is that a UTM is a TM which accepts a description of *any* TM
> as part of its input string.

If we narrowly define a TM to be the most conventional then this would
be true. It is not totally impossible to adapt the concept of a TM to
write 32-bit integers instead of bits.

> The set of all possible TMs includes TMs
> which use entirely different alphabets and a UTM must be able to deal
> with *all* of these. The TM being emulated may have a smaller or larger
> alphabet than the UTM makes use of.
>

Conventionally its tape alphabet is {1, SPACE}. I forgot that it does
not even conventionally have 0.

> If you read the paper to which I gave you a link, it will explain how
> this is accomplished and give examples of actual, fully specified UTMs.
> It will clear up many of your misconceptions and then you can reread
> this thread and you might actually grasp what is being said. If you
> don't understand how UTMs work (and you don't), you shouldn't be telling
> people they are wrong when they try to explain to you how UTMs actually
> work. It just makes you look foolish.
>
>>> seems to be a general pattern that you have -- when people try to
>>> correct a misconception you have or some terminological error you
>>> don't try to appreciate subtle distinctions which they are trying to
>>> draw to your attention and instead come up with some more ridiculous
>>> interpretation of what is being said and then steadfastly hold onto
>>> that interpretation.
>>>
>>> You claim that you want to learn how to express yourself correctly so
>>> people will take your work seriously and Ben is trying to draw your
>>> attention to the fact that you are not expressing yourself in a way
>>> that is strictly accurate, but you're actively resisting trying to
>>> learn from what he is saying.
>>>
>>> I gave you a link to a paper which describes how UTMs work. If you
>>> actually read through that paper and then reread this thread maybe
>>> you will realize the point that people are trying to make.
>>>
>>> If you simply keep insisting that Ben is wrong and you are right and
>>> that everyone else are liars you're never going to learn to express
>>> yourself in a way that will be taken seriously which you claim is one
>>> of your goals.
>>>
>>> André
>>>
>>
>> How can the UTM simulation of a machine that copies a string not
>> perform the functional equivalent of copying a string and still be an
>> accurate simulation of this TM?
>
> Ben never made any claims that it didn't perform some operation which
> could be construed as the functional equivalent of copying a string. He
> claimed that there was no *literal* copying involved except in the first
> instance.


Click here to read the complete article
Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ intentional bias == Liar ]

<sgb3lt$h1f$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ intentional bias == Liar ]
Date: Fri, 27 Aug 2021 10:25:32 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 43
Message-ID: <sgb3lt$h1f$1@dont-email.me>
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com> <sg851a$gfp$1@dont-email.me>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
<sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
<3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>
<fpqdnUlVMav3lrT8nZ2dnUU7-KHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 27 Aug 2021 16:25:33 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="623c4a397b26e2cc1f9b7d202736166b";
logging-data="17455"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+S7kUFM1Gm+P2N1zj5SBUh"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:bY9QOylG7gcNZVrL1PKMphdNKl0=
In-Reply-To: <fpqdnUlVMav3lrT8nZ2dnUU7-KHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 27 Aug 2021 16:25 UTC

On 2021-08-27 09:57, olcott wrote:
> On 8/27/2021 10:20 AM, Malcolm McLean wrote:
>> On Friday, 27 August 2021 at 16:11:45 UTC+1, olcott wrote:
>>>
>>> How can the UTM simulation of a machine that copies a string not perform
>>> the functional equivalent of copying a string and still be an accurate
>>> simulation of this TM?
>>>
>> If the machine simply copies the input string, then the UTM simulation
>> must
>> place a copy of the input on the tape before it terminates.
>
> Because Ben said this is not true Ben is wrong.

You're misconstruing both Ben and Malcolm here. Please pay special
attention to the word *intermediate* in the next sentence.

You keep talking about a UTM as a 'simulator', but that's really only a
metaphor, and it is one that perhaps you are taking far too literally.

A UTM is a TM which takes as its input the description of a computation
(i.e. the description of a TM concatenated with an input string) and
computes what the *result* of that computation would be. There is
absolutely no requirement that any intermediate data which would be
written to the tape by the TM described by the input be duplicated. The
final result is all that matters.

It might be better for you to think of a UTM as a TM which *analyzes*
the description of a TM + input string and determines what that TM would
do rather than a TM which simulates another TM.

André

>> However the intermediate
>> steps don't have to be particularly close, you probably won't see the
>> input string
>> appear in a recognisable form until the last few steps.

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ intentional bias == Liar ]

<u82dnVdcG6VNiLT8nZ2dnUU78cPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!border2.nntp.ams1.giganews.com!nntp.giganews.com!buffer2.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 27 Aug 2021 11:41:51 -0500
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ intentional bias == Liar ]
Newsgroups: comp.theory
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com>
<sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com>
<sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
<sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
<3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>
<fpqdnUlVMav3lrT8nZ2dnUU7-KHNnZ2d@giganews.com> <sgb3lt$h1f$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Fri, 27 Aug 2021 11:41:50 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <sgb3lt$h1f$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <u82dnVdcG6VNiLT8nZ2dnUU78cPNnZ2d@giganews.com>
Lines: 57
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-n0N3oQ+aRAikkhmVY3CVJnjIj8UZiR5p3ZJNpoKGVuZSYwZDi7TCYer4tfRkXvuFwGLUZJi7ry9c+f8!o3K+1OqzCQas4WR0HB7AuAbfkJtLlMwl+8lJkIevjeHb7GlBLAlufkDfjuzF9bDosJIs8cbY7pB8!W20=
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: 4380
 by: olcott - Fri, 27 Aug 2021 16:41 UTC

On 8/27/2021 11:25 AM, André G. Isaak wrote:
> On 2021-08-27 09:57, olcott wrote:
>> On 8/27/2021 10:20 AM, Malcolm McLean wrote:
>>> On Friday, 27 August 2021 at 16:11:45 UTC+1, olcott wrote:
>>>>
>>>> How can the UTM simulation of a machine that copies a string not
>>>> perform
>>>> the functional equivalent of copying a string and still be an accurate
>>>> simulation of this TM?
>>>>
>>> If the machine simply copies the input string, then the UTM
>>> simulation must
>>> place a copy of the input on the tape before it terminates.
>>
>> Because Ben said this is not true Ben is wrong.
>
> You're misconstruing both Ben and Malcolm here. Please pay special
> attention to the word *intermediate* in the next sentence.
>
> You keep talking about a UTM as a 'simulator', but that's really only a
> metaphor, and it is one that perhaps you are taking far too literally.
>
> A UTM is a TM which takes as its input the description of a computation
> (i.e. the description of a TM concatenated with an input string) and
> computes what the *result* of that computation would be. There is
> absolutely no requirement that any intermediate data which would be
> written to the tape by the TM described by the input be duplicated. The
> final result is all that matters.
>
> It might be better for you to think of a UTM as a TM which *analyzes*
> the description of a TM + input string and determines what that TM would
> do rather than a TM which simulates another TM.
>

If one is very careful to make sure that one uses sufficiently vague
language one can be certainly never sufficiently understood.

When we make every detail of a UTM concrete that such it actually
executes on a physical computer then all the vagueness is abolished and
the UTM is an interpreter of the source code of TMs.

> André
>
>>> However the intermediate
>>> steps don't have to be particularly close, you probably won't see the
>>> input string
>>> appear in a recognisable form until the last few steps.
>
>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ distinct computations ]

<sgb6d9$4qs$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ distinct computations ]
Date: Fri, 27 Aug 2021 11:12:07 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 126
Message-ID: <sgb6d9$4qs$1@dont-email.me>
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<sg77hh$l67$1@dont-email.me> <IrGdnY_9cdGtELr8nZ2dnUU7-WvNnZ2d@giganews.com>
<sg851a$gfp$1@dont-email.me> <lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com>
<sg8796$na$1@dont-email.me> <rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com>
<sg89cq$fme$1@dont-email.me> <5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
<sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
<sgb20e$ojg$1@dont-email.me> <N_-dne9M3cTwjbT8nZ2dnUU7-bnNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 27 Aug 2021 17:12:09 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="623c4a397b26e2cc1f9b7d202736166b";
logging-data="4956"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18pTqeZ5GllX/p697dgSzV9"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:YJQ255jyOj9MXIzU6lms/Khnr28=
In-Reply-To: <N_-dne9M3cTwjbT8nZ2dnUU7-bnNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 27 Aug 2021 17:12 UTC

On 2021-08-27 10:18, olcott wrote:
> On 8/27/2021 10:57 AM, André G. Isaak wrote:
>> On 2021-08-27 09:11, olcott wrote:
>>> On 8/27/2021 9:27 AM, André G. Isaak wrote:

>> TMs don't have "source code".
>
> The machine description of a TM that is simulated on a UTM is for all
> practical purposes source-code that is interpreted. There are no
> material differences.

A machine description doesn't even remotely resemble "source code". The
problem is that you've never actually looked at real TMs or real UTMs.

>> We're not dealing with programming languages here. If a UTM is
>> emulating a TM which makes a copy of a string, it must write some
>> representation to the tape, but Ben's point was that this won't be a
>> *literal* copy of that string. It may be something which looks
>> entirely different.
>>
>>>> You've latched onto a rather absurd interpretation of what he is
>>>> saying and are refusing to try to understand what he is *actually*
>>>> saying which is something far more nuanced than your absurd
>>>> interpretation, and this
>>>
>>> He is saying the the UTM and the TM cold be defined on the basis of
>>> incompatible specification of the defined of a TM. One might use bits
>>> as its basis data type and the other might use bytes.
>>
>> TMs don't use bits or bytes. Again, you need to stop thinking of TMs
>> in terms of programming languages or existing computer hardware. They
>> are mathematical abstractions unrelated to either of these things.
>>
> So when a TM writes to its tape what it is writing?
> Conventionally it is writing a bit.

It is writing a *symbol* from its alphabet. If there are only two
symbols in the alphabet, you might view that as a 'bit', but a TM can
use any number of symbols. The alphabet is part of the definition of the TM.

>> The point is that a UTM is a TM which accepts a description of *any*
>> TM as part of its input string.
>
> If we narrowly define a TM to be the most conventional then this would
> be true.

What do you mean by 'narrowly define a TM'?

> It is not totally impossible to adapt the concept of a TM to
> write 32-bit integers instead of bits.

Since TMs don't write bits, the above is unclear. If you mean we could
define a TM which uses an alphabet consisting of 4,294,967,296 symbols,
then sure, we could, though I'm not sure why you would want to.

>> The set of all possible TMs includes TMs which use entirely different
>> alphabets and a UTM must be able to deal with *all* of these. The TM
>> being emulated may have a smaller or larger alphabet than the UTM
>> makes use of.
>>
>
> Conventionally its tape alphabet is {1, SPACE}. I forgot that it does
> not even conventionally have 0.

TMs are not restricted to using any particular alphabet. A UTM must be
able to accept the description of a TM which uses {1, space}, or one
that uses {A, B, C, space} or {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} or any
other imaginable alphabet.

You keep using the word 'conventional' when what you really mean is
'what was used in the introductory textbook I happened to read'.

>> If you read the paper to which I gave you a link, it will explain how
>> this is accomplished and give examples of actual, fully specified
>> UTMs. It will clear up many of your misconceptions and then you can
>> reread this thread and you might actually grasp what is being said. If
>> you don't understand how UTMs work (and you don't), you shouldn't be
>> telling people they are wrong when they try to explain to you how UTMs
>> actually work. It just makes you look foolish.
>>
>>>> seems to be a general pattern that you have -- when people try to
>>>> correct a misconception you have or some terminological error you
>>>> don't try to appreciate subtle distinctions which they are trying to
>>>> draw to your attention and instead come up with some more ridiculous
>>>> interpretation of what is being said and then steadfastly hold onto
>>>> that interpretation.
>>>>
>>>> You claim that you want to learn how to express yourself correctly
>>>> so people will take your work seriously and Ben is trying to draw
>>>> your attention to the fact that you are not expressing yourself in a
>>>> way that is strictly accurate, but you're actively resisting trying
>>>> to learn from what he is saying.
>>>>
>>>> I gave you a link to a paper which describes how UTMs work. If you
>>>> actually read through that paper and then reread this thread maybe
>>>> you will realize the point that people are trying to make.
>>>>
>>>> If you simply keep insisting that Ben is wrong and you are right and
>>>> that everyone else are liars you're never going to learn to express
>>>> yourself in a way that will be taken seriously which you claim is
>>>> one of your goals.
>>>>
>>>> André
>>>>
>>>
>>> How can the UTM simulation of a machine that copies a string not
>>> perform the functional equivalent of copying a string and still be an
>>> accurate simulation of this TM?
>>
>> Ben never made any claims that it didn't perform some operation which
>> could be construed as the functional equivalent of copying a string.
>> He claimed that there was no *literal* copying involved except in the
>> first instance.
>
> So in other words he said that my high level abstraction was wrong on
> the basis that it was a high level abstraction and did not delve into
> the tedious details of how this high level abstraction is implemented.

No, he was claiming that your high level abstraction was *misleading*
and belied a lack of understanding of UTMs on your part.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: How do we know H(P,P)==0 is the correct halt status for the input to H? [ intentional bias == Liar ]

<sgb6mo$a8s$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: How do we know H(P,P)==0 is the correct halt status for the input
to H? [ intentional bias == Liar ]
Date: Fri, 27 Aug 2021 11:17:10 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 62
Message-ID: <sgb6mo$a8s$1@dont-email.me>
References: <3YOdnecvDsA5Q4r8nZ2dnUU7-TXNnZ2d@giganews.com>
<lJGdncI-4tifAbr8nZ2dnUU7-R_NnZ2d@giganews.com> <sg8796$na$1@dont-email.me>
<rsKdnbAXWp7jPrr8nZ2dnUU7-I_NnZ2d@giganews.com> <sg89cq$fme$1@dont-email.me>
<5L-dnYPQCYavN7r8nZ2dnUU7-eednZ2d@giganews.com>
<p8WdnTRK2qBPMbr8nZ2dnUU7-c3NnZ2d@giganews.com> <sg8fk0$v9f$1@dont-email.me>
<0vydnSb6TL2ZW7r8nZ2dnUU7-TfNnZ2d@giganews.com> <sg8l27$bb1$1@dont-email.me>
<CpudnZ-zNfqdRLr8nZ2dnUU7-S2dnZ2d@giganews.com>
<%dVVI.4471$o45.2514@fx46.iad>
<e5qdnexvgZsdvLX8nZ2dnUU7-WednZ2d@giganews.com> <HJWVI.42$dI3.12@fx10.iad>
<sg9do3$620$1@dont-email.me> <SLidnUazxu8Mz7X8nZ2dnUU7-WfNnZ2d@giganews.com>
<634WI.2231$tG6.308@fx39.iad> <-L-dnaA4AcGTb7X8nZ2dnUU7-VXNnZ2d@giganews.com>
<sgasok$ssl$1@dont-email.me> <Jc-dnWjkGtc3nbT8nZ2dnUU7-Y3NnZ2d@giganews.com>
<3c46a45d-cb96-4bd3-994e-3680f79ff7een@googlegroups.com>
<fpqdnUlVMav3lrT8nZ2dnUU7-KHNnZ2d@giganews.com> <sgb3lt$h1f$1@dont-email.me>
<u82dnVdcG6VNiLT8nZ2dnUU78cPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 27 Aug 2021 17:17:12 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="623c4a397b26e2cc1f9b7d202736166b";
logging-data="10524"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18X95DVnaGeWUTn69N9QScR"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:8NHvsbVwKc5AJSZmIlFbPNoWgtI=
In-Reply-To: <u82dnVdcG6VNiLT8nZ2dnUU78cPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 27 Aug 2021 17:17 UTC

On 2021-08-27 10:41, olcott wrote:
> On 8/27/2021 11:25 AM, André G. Isaak wrote:
>> On 2021-08-27 09:57, olcott wrote:
>>> On 8/27/2021 10:20 AM, Malcolm McLean wrote:
>>>> On Friday, 27 August 2021 at 16:11:45 UTC+1, olcott wrote:
>>>>>
>>>>> How can the UTM simulation of a machine that copies a string not
>>>>> perform
>>>>> the functional equivalent of copying a string and still be an accurate
>>>>> simulation of this TM?
>>>>>
>>>> If the machine simply copies the input string, then the UTM
>>>> simulation must
>>>> place a copy of the input on the tape before it terminates.
>>>
>>> Because Ben said this is not true Ben is wrong.
>>
>> You're misconstruing both Ben and Malcolm here. Please pay special
>> attention to the word *intermediate* in the next sentence.
>>
>> You keep talking about a UTM as a 'simulator', but that's really only
>> a metaphor, and it is one that perhaps you are taking far too literally.
>>
>> A UTM is a TM which takes as its input the description of a
>> computation (i.e. the description of a TM concatenated with an input
>> string) and computes what the *result* of that computation would be.
>> There is absolutely no requirement that any intermediate data which
>> would be written to the tape by the TM described by the input be
>> duplicated. The final result is all that matters.
>>
>> It might be better for you to think of a UTM as a TM which *analyzes*
>> the description of a TM + input string and determines what that TM
>> would do rather than a TM which simulates another TM.
>>
>
> If one is very careful to make sure that one uses sufficiently vague
> language one can be certainly never sufficiently understood.

You're the one who is using vague language. People here are trying to
help you make your language *less* vague. I don't see why you are so
resistant to this effort.

> When we make every detail of a UTM concrete that such it actually
> executes on a physical computer then all the vagueness is abolished and
> the UTM is an interpreter of the source code of TMs.

I gave you a link to a paper that contained fully specified descriptions
of several UTMs. There operation is fully and precisely described with
absolutely no vagueness.

Your obsession with executing things on physical computers is strange.
TMs are not intended as models of physical computers, nor are they
programming languages. They were conceived of as a mathematical tool
before modern computers even existed.

If you insist on seeing the UTM executed on a real computer, you could
simply take one of the UTM descriptions in the paper I gave you and run
it in one of the many TM emulators out there.

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Pages:12345678910111213141516171819
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor