Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Base 8 is just like base 10, if you are missing two fingers. -- Tom Lehrer


devel / comp.theory / Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

SubjectAuthor
* Concise refutation of halting problem proofs V27 [ finallyolcott
+* Concise refutation of halting problem proofs V27 [ finallyolcott
|`* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
| `* Concise refutation of halting problem proofs V27 [ finallyolcott
|  +- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|  `* Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|   `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |`* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    | `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |  +* Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |  |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |  | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |  `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |   `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |+* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||+* Concise refutation of halting problem proofs V27 [ finallyMalcolm McLean
|    |    | | |||`* Concise refutation of halting problem proofs V27 [ finally mathematically precisBen Bacarisse
|    |    | | ||| `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |||  `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |||   `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |||    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | ||`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | || +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | || `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | ||   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | ||   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | ||   | `- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |  `* Concise refutation of halting problem proofs V27 [ finally mathematically precisolcott
|    |    | | |   |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |  +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   |  |+- Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   |  |+- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |  |`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   |   |  `* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   +* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   | +- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   | `* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  +* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  |+* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  ||`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || +* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  || |+* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || ||+- Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  || ||`- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  || |`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || | `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  || `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  |`- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  `* Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   +* Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   |+- Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |   |`- Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   `- Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon

Pages:1234
Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<sni135$54o$2@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Mon, 22 Nov 2021 23:18:13 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 31
Message-ID: <sni135$54o$2@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 06:18:13 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="5272"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/pBeAtbACOUttz3yhmGDIt"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:Z67RiCHKnI9umjuARTxcL+TCDuY=
In-Reply-To: <Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 06:18 UTC

On 2021-11-22 23:07, olcott wrote:
> On 11/22/2021 11:42 PM, olcott wrote:
>> On 11/22/2021 10:20 PM, André G. Isaak wrote:

>>> And you still haven't actually answered my question:
>>>
>>> What does it *mean* for the 'input', something which is not a
>>> computation, to halt?
>>>
>
> In my first example the input is directly executed so you are still
> basing your comments on what you think that I must saying instead of
> what I am actually saying.

Which first example? No examples of anything were given in the post you
are responding to. And what does 'the input is directly executed mean'?
The input is a string which cannot be executed at all. You mean the
independent computation referred to by the input? Or do you mean
something else?

> I threw direct execution the mix to quell the nutty baseless statements
> about incorrect simulation.

And that answers my question how exactly?

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ad4:5f87:: with SMTP id jp7mr3998038qvb.65.1637654679394;
Tue, 23 Nov 2021 00:04:39 -0800 (PST)
X-Received: by 2002:a25:9d86:: with SMTP id v6mr4186135ybp.179.1637654679179;
Tue, 23 Nov 2021 00:04:39 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.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: Tue, 23 Nov 2021 00:04:39 -0800 (PST)
In-Reply-To: <sni135$54o$2@dont-email.me>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:a83b:8465:fce6:68f1;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:a83b:8465:fce6:68f1
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com> <TtUmJ.126712$831.100143@fx40.iad>
<snh4jm$a0i$1@dont-email.me> <cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Tue, 23 Nov 2021 08:04:39 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Lines: 23
 by: Malcolm McLean - Tue, 23 Nov 2021 08:04 UTC

On Tuesday, 23 November 2021 at 06:18:15 UTC, André G. Isaak wrote:
> On 2021-11-22 23:07, olcott wrote:
> > On 11/22/2021 11:42 PM, olcott wrote:
> >> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>
> >>> And you still haven't actually answered my question:
> >>>
> >>> What does it *mean* for the 'input', something which is not a
> >>> computation, to halt?
> >>>
> >
> > In my first example the input is directly executed so you are still
> > basing your comments on what you think that I must saying instead of
> > what I am actually saying.
> Which first example? No examples of anything were given in the post you
> are responding to. And what does 'the input is directly executed mean'?
> The input is a string which cannot be executed at all. You mean the
> independent computation referred to by the input? Or do you mean
> something else?
>
You're mixing up PO's system with Linz's Turing machine.
In PO's system, the input is the address of the machine code for H_Hat.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<8735nney5m.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]
Date: Tue, 23 Nov 2021 14:37:09 +0000
Organization: A noiseless patient Spider
Lines: 25
Message-ID: <8735nney5m.fsf@bsb.me.uk>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com>
<snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>
<sni135$54o$2@dont-email.me>
<bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="8eb52a1cb63455e5c0003813e8c7219d";
logging-data="29441"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+e/i0e2GDATyI7/20swUJpFA1RG/tgKnA="
Cancel-Lock: sha1:K0vhUeldNC1U25StqQ6c1DWSilA=
sha1:rIgdKseAJFcIJW4qI9q+LV+0RoA=
X-BSB-Auth: 1.6de7df20727a53cea91d.20211123143709GMT.8735nney5m.fsf@bsb.me.uk
 by: Ben Bacarisse - Tue, 23 Nov 2021 14:37 UTC

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

> On Tuesday, 23 November 2021 at 06:18:15 UTC, André G. Isaak wrote:

>> The input is a string which cannot be executed at all. You mean the
>> independent computation referred to by the input? Or do you mean
>> something else?
>>
> You're mixing up PO's system with Linz's Turing machine.
> In PO's system, the input is the address of the machine code for
> H_Hat.

Ha! André is not mixing them up, PO flip-flopping between and so André
is perfectly entitled to refer to either. PO uses H for both, sometimes
posting Linz-like descriptions of behaviour (the |- lines he does not
understand) and sometimes scraps of C code. It's not uncommon for both
to appear in the same post. I fact in this very thread PO writes:

"You can't correctly pass anything to H besides the pair of finite
strings or references to the machine language of P"

Which is wrong, but not wrong in a way that makes any real difference.

--
Ben.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 08:59:36 -0600
Date: Tue, 23 Nov 2021 08:59:35 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sni0pq$54o$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-o0Wx9FWmF8Wbm4/4qReEtTvGLXz0FTzKIGP6yWzcPU1Qc61enyYuFX1IjHqa981vP/77EaXKeZzCjCE!2SMOYGTajRvwuRNmD7nDL70r2fnnlE47qE9lMIqZE0afORBiziGuuIsRN1KpqIonDrEKJ01uNlby!TQ==
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: 3674
 by: olcott - Tue, 23 Nov 2021 14:59 UTC

On 11/23/2021 12:13 AM, André G. Isaak wrote:
> On 2021-11-22 22:42, olcott wrote:
>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>
>>> And that's what the halting problem is about. Determining whether an
>>> independent computation halts. Unless H is part of the input string
>>> why on earth would H be involved in the independent execution?
>>>
>>>> No deciders can actually work that way. All deciders either accept
>>>> or reject finite string inputs.
>>>
>>> And they reject them based on whether the independent computation
>>> described by those strings halt or not. Why would this be a problem?
>>>
>>
>> You can't correctly pass anything to H besides the pair of finite
>> strings or references to the machine language of P.
>>
>> Its inputs are not allowed to have the extra criteria that you assume,
>> thus have no basis to apply it.
>
> Which 'extra criteria'? The inputs to a halt decider are nothing more
> than a finite string exactly as specified in the definition of 'halt
> decider'.
>
> André
>
>

H is only allowed to have two copies or two references to the machine
code of P as its input corresponding to the finite strings of the TM
description and its input.

Since this input cannot contain criteria to distinguish its execution or
simulation outside of H from its its execution or simulation by H anyone
that says H must report on the behavior of the execution or simulation
outside of H is incorrect. H is not allowed to know the difference.

For every input besides pathological inputs the execution or simulation
of the input by H is identical to the execution or simulation of this
same input outside of H.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 09:02:11 -0600
Date: Tue, 23 Nov 2021 09:02:10 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sni135$54o$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-CCE1vOQkEYfMNfFjG6pi6oYipli09Qp0jBPAgppaIXz/QeE9uL7HPXqqX0BO1ouyj86FnKZksU2CEoR!uZ7uyFFd2kVvDWzokY8gQLC528ppSQqtK4dX4IqbIu8RCZTVrpgEtqVrERxFOaXSCEKysvIS94Rh!Uw==
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: 3464
 by: olcott - Tue, 23 Nov 2021 15:02 UTC

On 11/23/2021 12:18 AM, André G. Isaak wrote:
> On 2021-11-22 23:07, olcott wrote:
>> On 11/22/2021 11:42 PM, olcott wrote:
>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>
>>>> And you still haven't actually answered my question:
>>>>
>>>> What does it *mean* for the 'input', something which is not a
>>>> computation, to halt?
>>>>
>>
>> In my first example the input is directly executed so you are still
>> basing your comments on what you think that I must saying instead of
>> what I am actually saying.
>
> Which first example? No examples of anything were given in the post you
> are responding to. And what does 'the input is directly executed mean'?
> The input is a string which cannot be executed at all. You mean the

#include <stdint.h>
#include <stdio.h>
typedef int (*ptr)();

int H(ptr x, ptr y)
{ x(y); // direct execution of P(P)
return 1;
}

// Minimal essence of Linz(1990) Ĥ
// and Strachey(1965) P
int P(ptr x)
{ H(x, x);
return 1; // Give P a last instruction at the "c" level
}

int main(void)
{ H(P, P);
}

In the above basis of this whole post H directly invokes P(P).

> independent computation referred to by the input? Or do you mean
> something else?
>
>> I threw direct execution the mix to quell the nutty baseless
>> statements about incorrect simulation.
>
> And that answers my question how exactly?
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<qOednbP80rOnngD8nZ2dnUU7-KXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 09:05:30 -0600
Date: Tue, 23 Nov 2021 09:05:29 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>
<8735nney5m.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <8735nney5m.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qOednbP80rOnngD8nZ2dnUU7-KXNnZ2d@giganews.com>
Lines: 35
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-qtzb0RGs0SFtgbZlDINH5vtcGzJOF2CPyCfAOPRzt2RjuWjqQsRPTYU9cxpujvo2Q6+2VO6BeHgUM6K!CDNB045wrt8ggQOYhorikgu34WAxI4x01x0tbW+9LcMOvqD1nSLG9eN3O8UASauUQIum4WYpIbrv!xA==
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: 3383
 by: olcott - Tue, 23 Nov 2021 15:05 UTC

On 11/23/2021 8:37 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Tuesday, 23 November 2021 at 06:18:15 UTC, André G. Isaak wrote:
>
>>> The input is a string which cannot be executed at all. You mean the
>>> independent computation referred to by the input? Or do you mean
>>> something else?
>>>
>> You're mixing up PO's system with Linz's Turing machine.
>> In PO's system, the input is the address of the machine code for
>> H_Hat.
>
> Ha! André is not mixing them up, PO flip-flopping between and so André
> is perfectly entitled to refer to either. PO uses H for both, sometimes
> posting Linz-like descriptions of behaviour (the |- lines he does not
> understand) and sometimes scraps of C code. It's not uncommon for both
> to appear in the same post. I fact in this very thread PO writes:
>
> "You can't correctly pass anything to H besides the pair of finite
> strings or references to the machine language of P"
>
> Which is wrong, but not wrong in a way that makes any real difference.
>

Thanks again for your superb simplification of my syntax.
I knew about the idea of function pointers but didn't know the syntax
required to make the simplifications that you provided.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<SF8nJ.81813$Wkjc.17840@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news.uzoreto.com!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 132
Message-ID: <SF8nJ.81813$Wkjc.17840@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: Tue, 23 Nov 2021 11:29:27 -0500
X-Received-Bytes: 7429
 by: Richard Damon - Tue, 23 Nov 2021 16:29 UTC

On 11/23/21 12:42 AM, olcott wrote:
> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>> On 2021-11-22 20:59, olcott wrote:
>>> On 11/22/2021 7:44 PM, André G. Isaak wrote:
>>>> On 2021-11-22 18:16, olcott wrote:
>>>>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>>>>> On 2021-11-22 17:13, olcott wrote:
>>>>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> And this bit is particularly mystifying:
>>>>>>>>
>>>>>>>>  > PSR_set: for n = 0 to ∞
>>>>>>>>  > {
>>>>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>>>>  > }
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Numbered elements of the infinite set of finite string C
>>>>>>> encodings of H and P. The source-code that I provided is the (H0,
>>>>>>> P0) element.
>>>>>>
>>>>>> That wasn't the mystifying part despite it being a strange abuse
>>>>>> of syntax. I assumed this was just a deranged way of writing ∀n
>>>>>> rather than being a syntactically ill-formed C program, though why
>>>>>> you continuously insist on inventing your own undefined notation
>>>>>> is beyond me.
>>>>>>
>>>>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes
>>>>>> halt?
>>>>>
>>>>> The input to Hn(Pn,Pn) never reaches its final state.
>>>>> For some of these exact same Pn(Pn) P does reach its final state.
>>>>
>>>> Which goes back to Richard's question which you refused to answer:
>>>> What does Input_Never_Halts mean?
>>>>
>>>> The input to a halt decider is a *string*. The input can't halt. It
>>>> also can't not halt. Only the computation which it describes has a
>>>> halting status, and in the case of Hn(Pn, Pn) the input describes
>>>> the computation Pn(Pn).
>>>>
>>>> You keep talking about what the 'input' does, but unless by 'input'
>>>> you mean 'the computation described by the input' this is a
>>>> completely undefined and, as far as I can tell, meaningless notion.
>>>> Halting is a property of *computations*, not of strings.
>>>>
>>>> So what does Input_Never_Halts mean?
>>>>
>>>> What does it mean for an input to halt or not halt?
>>>>
>>>
>>> It turns out that the independent execution of P(P) actually means an
>>> input to H(P,P) that *is not* an input to H(P,P).
>>
>> Which is a meaningless statement. How can X be an input to Y that is
>> not an input to Y?
>>
>>> It turns out that the independent execution of P(P) means that main()
>>> directly executes P(P) without H being involved.
>>
>> And that's what the halting problem is about. Determining whether an
>> independent computation halts. Unless H is part of the input string
>> why on earth would H be involved in the independent execution?
>>
>>> No deciders can actually work that way. All deciders either accept or
>>> reject finite string inputs.
>>
>> And they reject them based on whether the independent computation
>> described by those strings halt or not. Why would this be a problem?
>>
>
> You can't correctly pass anything to H besides the pair of finite
> strings or references to the machine language of P.
>
> Its inputs are not allowed to have the extra criteria that you assume,
> thus have no basis to apply it.

So, are you saying the strings (aka words) can't have meaning beyond
just the symbols they contain.

"LIAR" is just a sequence of the letters L, I, A, and R?

The input sequence to the decider is a string of some sort the fully
represents the algorithm and input that form a computation that can be
performed.

The SOLE purpose of a decider is to look at that input string, and by
doing some sort of processing tell us reliably in finite time properties
of what that string represents. For a Halting Decider, that would be
what would happen if we actually executed the computation represented,
which equivalently would mean if we gave this input to a true UTM which
UNCONDITIONALLY executed that input string.

This is not an 'Extra Criteria', this is the JOB DESCRIPTION of the Halt
Decider.

No one really cares aboutwhat processing the decider does, and if it can
see the final halting state or not, because the interest is TOTALLY in
the original computation that the representation that is the input came
from. THAT is independent of what decider we ask, so can't be dependent
on anything that decider does.

It is sort of like going to an advisor with a business plan that is
going to cost a lot of money and effort to execute. Ideally, you want an
advisor that can look at your description of the plan and tell you if it
is likely to work without needing to actually try the plan. Different
advisors might give you different advise, but unless they help you
modify the plan, what they say isn't going to actually affect what would
happen when you execute the plan.

Think of a Halt Decider as that Advisor, it needs to figure out if the
program will succeed and give an answer, or if it will run forever, and
isn't worth running.

The one difference is that in the advisor case, they are working with
imperfect knowledge, and so do need to make some 'guesses', but a Halt
Decider is given a problem which we KNOW has a single distinct correct
answer. By DEFINITION, a given computation will always either halt or be
non-halting, and can't be anything else. The second part is that the
Halt Decider needs to be itself a 'program', and thus is usable by the
program that it is being asked about, and this interaction leads to
cases where the decider can't make a proper decision.

This interaction doesn't make some other answer right, it just makes it
impossible for the given program to give the right answer (but some
other program might be able to).

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<hI8nJ.81814$Wkjc.60451@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 128
Message-ID: <hI8nJ.81814$Wkjc.60451@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: Tue, 23 Nov 2021 11:32:03 -0500
X-Received-Bytes: 6558
 by: Richard Damon - Tue, 23 Nov 2021 16:32 UTC

On 11/23/21 1:07 AM, olcott wrote:
> On 11/22/2021 11:42 PM, olcott wrote:
>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>> On 2021-11-22 20:59, olcott wrote:
>>>> On 11/22/2021 7:44 PM, André G. Isaak wrote:
>>>>> On 2021-11-22 18:16, olcott wrote:
>>>>>> On 11/22/2021 7:07 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-22 17:13, olcott wrote:
>>>>>>>> On 11/22/2021 5:16 PM, André G. Isaak wrote:
>>>>>>>
>>>>>>>>> And this bit is particularly mystifying:
>>>>>>>>>
>>>>>>>>>  > PSR_set: for n = 0 to ∞
>>>>>>>>>  > {
>>>>>>>>>  >    (Input_Never_Halts(  Hn(Pn,Pn)  ))
>>>>>>>>>  >    (Sometimes_Halts(  Hn(Pn,Pn)  ))
>>>>>>>>>  >    (Sometimes_Halts(   Pn(Pn)  ))
>>>>>>>>>  > }
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Numbered elements of the infinite set of finite string C
>>>>>>>> encodings of H and P. The source-code that I provided is the
>>>>>>>> (H0, P0) element.
>>>>>>>
>>>>>>> That wasn't the mystifying part despite it being a strange abuse
>>>>>>> of syntax. I assumed this was just a deranged way of writing ∀n
>>>>>>> rather than being a syntactically ill-formed C program, though
>>>>>>> why you continuously insist on inventing your own undefined
>>>>>>> notation is beyond me.
>>>>>>>
>>>>>>> How can the input of Hn(Pn, Pn) never halt when Pn(Pn) sometimes
>>>>>>> halt?
>>>>>>
>>>>>> The input to Hn(Pn,Pn) never reaches its final state.
>>>>>> For some of these exact same Pn(Pn) P does reach its final state.
>>>>>
>>>>> Which goes back to Richard's question which you refused to answer:
>>>>> What does Input_Never_Halts mean?
>>>>>
>>>>> The input to a halt decider is a *string*. The input can't halt. It
>>>>> also can't not halt. Only the computation which it describes has a
>>>>> halting status, and in the case of Hn(Pn, Pn) the input describes
>>>>> the computation Pn(Pn).
>>>>>
>>>>> You keep talking about what the 'input' does, but unless by 'input'
>>>>> you mean 'the computation described by the input' this is a
>>>>> completely undefined and, as far as I can tell, meaningless notion.
>>>>> Halting is a property of *computations*, not of strings.
>>>>>
>>>>> So what does Input_Never_Halts mean?
>>>>>
>>>>> What does it mean for an input to halt or not halt?
>>>>>
>>>>
>>>> It turns out that the independent execution of P(P) actually means
>>>> an input to H(P,P) that *is not* an input to H(P,P).
>>>
>>> Which is a meaningless statement. How can X be an input to Y that is
>>> not an input to Y?
>>>
>>>> It turns out that the independent execution of P(P) means that
>>>> main() directly executes P(P) without H being involved.
>>>
>>> And that's what the halting problem is about. Determining whether an
>>> independent computation halts. Unless H is part of the input string
>>> why on earth would H be involved in the independent execution?
>>>
>>>> No deciders can actually work that way. All deciders either accept
>>>> or reject finite string inputs.
>>>
>>> And they reject them based on whether the independent computation
>>> described by those strings halt or not. Why would this be a problem?
>>>
>>
>> You can't correctly pass anything to H besides the pair of finite
>> strings or references to the machine language of P.
>>
>> Its inputs are not allowed to have the extra criteria that you assume,
>> thus have no basis to apply it.
>>
>>
>>> The fact that *your* H doesn't work correctly hardly indicates that
>>> no decider can work the way that it is supposed to work. (A universal
>>> halt decider obviously cannot, but that's because a universal halt
>>> decider cannot exist).
>>>
>>> And you still haven't actually answered my question:
>>>
>>> What does it *mean* for the 'input', something which is not a
>>> computation, to halt?
>>>
>
> In my first example the input is directly executed so you are still
> basing your comments on what you think that I must saying instead of
> what I am actually saying.
>
> I threw direct execution the mix to quell the nutty baseless statements
> about incorrect simulation.

Except that the version that directly execute don't answer, and the
versions that answer can't be directly executing, so the DON'T answer
the statements about incorrect simulation.

Remember, your P is dependent on H, so just because you can say
something about the P based on ONE H, doesn't mean that property applies
to other Ps.

You just LIE by assuming that it does.

>
>>> That's claiming that the *string* "123456" is even as opposed to the
>>> integer which that string represents. It has no sensible interpretation.
>>>
>>> And you still have not answered the other question I asked:
>>>
>>> what does it even mean for something to *sometimes* halt? For any
>>> given value of n it either halts or it doesn't.
>>>
>>> André
>>>
>>
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<MK8nJ.81815$Wkjc.59126@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 69
Message-ID: <MK8nJ.81815$Wkjc.59126@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: Tue, 23 Nov 2021 11:34:42 -0500
X-Received-Bytes: 3605
 by: Richard Damon - Tue, 23 Nov 2021 16:34 UTC

On 11/23/21 10:02 AM, olcott wrote:
> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>> On 2021-11-22 23:07, olcott wrote:
>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>
>>>>> And you still haven't actually answered my question:
>>>>>
>>>>> What does it *mean* for the 'input', something which is not a
>>>>> computation, to halt?
>>>>>
>>>
>>> In my first example the input is directly executed so you are still
>>> basing your comments on what you think that I must saying instead of
>>> what I am actually saying.
>>
>> Which first example? No examples of anything were given in the post
>> you are responding to. And what does 'the input is directly executed
>> mean'? The input is a string which cannot be executed at all. You mean
>> the
>
> #include <stdint.h>
> #include <stdio.h>
> typedef int (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y); // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1; // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> In the above basis of this whole post H directly invokes P(P).

Right, so THIS H creates a P that is non-halting, but this H never
answers (and can't answer with your claimed correct answer of 0) so it
fails to be a decider.

Since the computation P includes H, as soon as you change H to try to
give an answer, you have a DIFFERENT P, so the fact that this P0 was
non-halting doesn't apply to any other Pi.

>
>> independent computation referred to by the input? Or do you mean
>> something else?
>>
>>> I threw direct execution the mix to quell the nutty baseless
>>> statements about incorrect simulation.
>>
>> And that answers my question how exactly?
>>
>> André
>>
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<GO8nJ.55566$OB3.4535@fx06.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx06.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 56
Message-ID: <GO8nJ.55566$OB3.4535@fx06.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: Tue, 23 Nov 2021 11:38:52 -0500
X-Received-Bytes: 3903
 by: Richard Damon - Tue, 23 Nov 2021 16:38 UTC

On 11/23/21 9:59 AM, olcott wrote:
> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>> On 2021-11-22 22:42, olcott wrote:
>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>
>>>> And that's what the halting problem is about. Determining whether an
>>>> independent computation halts. Unless H is part of the input string
>>>> why on earth would H be involved in the independent execution?
>>>>
>>>>> No deciders can actually work that way. All deciders either accept
>>>>> or reject finite string inputs.
>>>>
>>>> And they reject them based on whether the independent computation
>>>> described by those strings halt or not. Why would this be a problem?
>>>>
>>>
>>> You can't correctly pass anything to H besides the pair of finite
>>> strings or references to the machine language of P.
>>>
>>> Its inputs are not allowed to have the extra criteria that you
>>> assume, thus have no basis to apply it.
>>
>> Which 'extra criteria'? The inputs to a halt decider are nothing more
>> than a finite string exactly as specified in the definition of 'halt
>> decider'.
>>
>> André
>>
>>
>
> H is only allowed to have two copies or two references to the machine
> code of P as its input corresponding to the finite strings of the TM
> description and its input.
>
> Since this input cannot contain criteria to distinguish its execution or
> simulation outside of H from its its execution or simulation by H anyone
> that says H must report on the behavior of the execution or simulation
> outside of H is incorrect. H is not allowed to know the difference.
>

You are missing the the criteria isn't 'part of the input' but part of
the PROBLEM STATEMENT that H is claiming to solve.

You don't seem to understand the basic concept of Problem Descriptions.

> For every input besides pathological inputs the execution or simulation
> of the input by H is identical to the execution or simulation of this
> same input outside of H.
>

So what, Getting some cases right doesn't mean it gets all cases right.
Your H does NOT correctly simulate any program that uses H as part of
its algorithm. FAIL.

It also doesn't prove that H will give an ANSWER for all other cases, so
it can still be wrong in other ways.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snj6bs$utp$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 09:54:18 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 57
Message-ID: <snj6bs$utp$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 16:54:20 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="31673"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+ExgwuFJSmjjxuePSVlbNG"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:ZXLCTacbbvByoZVJh2LQ73PvLME=
In-Reply-To: <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 16:54 UTC

On 2021-11-23 07:59, olcott wrote:
> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>> On 2021-11-22 22:42, olcott wrote:
>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>
>>>> And that's what the halting problem is about. Determining whether an
>>>> independent computation halts. Unless H is part of the input string
>>>> why on earth would H be involved in the independent execution?
>>>>
>>>>> No deciders can actually work that way. All deciders either accept
>>>>> or reject finite string inputs.
>>>>
>>>> And they reject them based on whether the independent computation
>>>> described by those strings halt or not. Why would this be a problem?
>>>>
>>>
>>> You can't correctly pass anything to H besides the pair of finite
>>> strings or references to the machine language of P.
>>>
>>> Its inputs are not allowed to have the extra criteria that you
>>> assume, thus have no basis to apply it.
>>
>> Which 'extra criteria'? The inputs to a halt decider are nothing more
>> than a finite string exactly as specified in the definition of 'halt
>> decider'.
>>
>> André
>>
>>
>
> H is only allowed to have two copies or two references to the machine
> code of P as its input corresponding to the finite strings of the TM
> description and its input.
>
> Since this input cannot contain criteria to distinguish its execution or
> simulation outside of H from its its execution or simulation by H anyone
> that says H must report on the behavior of the execution or simulation
> outside of H is incorrect. H is not allowed to know the difference.

There is no "extra criterion" being passed. The halting problem DEFINES
exactly what is to be answered, which is whether the *independent*
computation represented by the input halts, so the idea that the input
would need to somehow specify that the execution is "outside of H" is
nonsensical.

> For every input besides pathological inputs the execution or simulation
> of the input by H is identical to the execution or simulation of this
> same input outside of H.

Whatever you might mean by 'execution by H', this is not what the
halting problem asks about.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snj6fi$utp$2@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 09:56:17 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 59
Message-ID: <snj6fi$utp$2@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 16:56:18 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="31673"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18BC6c0owbZ+Hyj25Ko+ea+"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:w/T43UfMxDDnVfrehr4iOtND77M=
In-Reply-To: <ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 16:56 UTC

On 2021-11-23 08:02, olcott wrote:
> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>> On 2021-11-22 23:07, olcott wrote:
>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>
>>>>> And you still haven't actually answered my question:
>>>>>
>>>>> What does it *mean* for the 'input', something which is not a
>>>>> computation, to halt?
>>>>>
>>>
>>> In my first example the input is directly executed so you are still
>>> basing your comments on what you think that I must saying instead of
>>> what I am actually saying.
>>
>> Which first example? No examples of anything were given in the post
>> you are responding to. And what does 'the input is directly executed
>> mean'? The input is a string which cannot be executed at all. You mean
>> the
>
> #include <stdint.h>
> #include <stdio.h>
> typedef int (*ptr)();
>
> int H(ptr x, ptr y)
> {
>   x(y); // direct execution of P(P)
>   return 1;
> }
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1; // Give P a last instruction at the "c" level
> }
>
> int main(void)
> {
>   H(P, P);
> }
>
> In the above basis of this whole post H directly invokes P(P).

And the above cannot possibly form the basis for a halt decider because
there would then be no way to 'abort' the execution of a non-halting
input. Your approach depends on the input being simulated.

And of course the original problem concerns Turing Machines. It is not
even possible to 'call' the input where turing machines are concerned.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snj6k8$utp$3@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 09:58:48 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 15
Message-ID: <snj6k8$utp$3@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>
<8735nney5m.fsf@bsb.me.uk> <qOednbP80rOnngD8nZ2dnUU7-KXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 16:58:48 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="31673"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18L/lebyD5KfWPcv1na1A1/"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:yLusg0x8yhNQABzovFw00GUYvEQ=
In-Reply-To: <qOednbP80rOnngD8nZ2dnUU7-KXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 16:58 UTC

On 2021-11-23 08:05, olcott wrote:

> Thanks again for your superb simplification of my syntax.
> I knew about the idea of function pointers but didn't know the syntax
> required to make the simplifications that you provided.

This is a hilarious comment coming from someone who constantly berates
other people's knowledge of 'software engineering'. Any introductory
course on programming would cover this.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 11:50:11 -0600
Date: Tue, 23 Nov 2021 11:50:10 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snj6bs$utp$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
Lines: 71
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-asWahWiTL/b9xUAPba8i6BgXmtRoVPtqzhK6zIYwrmRVSWfQNYIxby1eFHhMhU3U/O4PuaBWrVz6y2P!Zb7Fw8YlFTzSkwt77nAqo3ai36C/kEe0DwmykLINfO/sxjSNDExEu7qRrawQwORznWZXYb4MC/3l!9Q==
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: 4616
 by: olcott - Tue, 23 Nov 2021 17:50 UTC

On 11/23/2021 10:54 AM, André G. Isaak wrote:
> On 2021-11-23 07:59, olcott wrote:
>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>> On 2021-11-22 22:42, olcott wrote:
>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>
>>>>> And that's what the halting problem is about. Determining whether
>>>>> an independent computation halts. Unless H is part of the input
>>>>> string why on earth would H be involved in the independent execution?
>>>>>
>>>>>> No deciders can actually work that way. All deciders either accept
>>>>>> or reject finite string inputs.
>>>>>
>>>>> And they reject them based on whether the independent computation
>>>>> described by those strings halt or not. Why would this be a problem?
>>>>>
>>>>
>>>> You can't correctly pass anything to H besides the pair of finite
>>>> strings or references to the machine language of P.
>>>>
>>>> Its inputs are not allowed to have the extra criteria that you
>>>> assume, thus have no basis to apply it.
>>>
>>> Which 'extra criteria'? The inputs to a halt decider are nothing more
>>> than a finite string exactly as specified in the definition of 'halt
>>> decider'.
>>>
>>> André
>>>
>>>
>>
>> H is only allowed to have two copies or two references to the machine
>> code of P as its input corresponding to the finite strings of the TM
>> description and its input.
>>
>> Since this input cannot contain criteria to distinguish its execution
>> or simulation outside of H from its its execution or simulation by H
>> anyone that says H must report on the behavior of the execution or
>> simulation outside of H is incorrect. H is not allowed to know the
>> difference.
>
> There is no "extra criterion" being passed. The halting problem DEFINES
> exactly what is to be answered, which is whether the *independent*
> computation represented by the input halts, so the idea that the input
> would need to somehow specify that the execution is "outside of H" is
> nonsensical.
>

You cannot** tell H that it cannot base its halt status decision on its
own simulation of its input.

**There is no way to say this (in x86 code) and the x86 code of P is
defined as its correct input equivalent to a TM description.

>> For every input besides pathological inputs the execution or
>> simulation of the input by H is identical to the execution or
>> simulation of this same input outside of H.
>
> Whatever you might mean by 'execution by H', this is not what the
> halting problem asks about.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 11:54:56 -0600
Date: Tue, 23 Nov 2021 11:54:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com> <snj6fi$utp$2@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snj6fi$utp$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com>
Lines: 73
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-iMuryV61PmuY351nvPnHeZjCei0RG37DOX/IK/WQ6m/xsbtNhPrVai4Vy5pCTANpC/DFleYkx7CtOx+!4vH7qyXOllZt05CRW5q4PqcGagAVc2nVcthgemjv5PV6ep09u1I1QBaPnT8YOfHv1fkyylA3m1PV!5g==
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: 4194
 by: olcott - Tue, 23 Nov 2021 17:54 UTC

On 11/23/2021 10:56 AM, André G. Isaak wrote:
> On 2021-11-23 08:02, olcott wrote:
>> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>>> On 2021-11-22 23:07, olcott wrote:
>>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>
>>>>>> And you still haven't actually answered my question:
>>>>>>
>>>>>> What does it *mean* for the 'input', something which is not a
>>>>>> computation, to halt?
>>>>>>
>>>>
>>>> In my first example the input is directly executed so you are still
>>>> basing your comments on what you think that I must saying instead of
>>>> what I am actually saying.
>>>
>>> Which first example? No examples of anything were given in the post
>>> you are responding to. And what does 'the input is directly executed
>>> mean'? The input is a string which cannot be executed at all. You
>>> mean the
>>
>> #include <stdint.h>
>> #include <stdio.h>
>> typedef int (*ptr)();
>>
>> int H(ptr x, ptr y)
>> {
>>    x(y); // direct execution of P(P)
>>    return 1;
>> }
>>
>> // Minimal essence of Linz(1990) Ĥ
>> // and Strachey(1965) P
>> int P(ptr x)
>> {
>>    H(x, x);
>>    return 1; // Give P a last instruction at the "c" level
>> }
>>
>> int main(void)
>> {
>>    H(P, P);
>> }
>>
>> In the above basis of this whole post H directly invokes P(P).
>
> And the above cannot possibly form the basis for a halt decider because
> there would then be no way to 'abort' the execution of a non-halting
> input. Your approach depends on the input being simulated.
>

None-the-less the above conclusively proves that any talk about the
simulation being incorrect is pure nonsense.

When H directly executes its input in the debug step mode of a debugger
we get the exact same result as when H simulates its input, thus anyone
saying that the simulation is incorrect is proven wrong.

> And of course the original problem concerns Turing Machines. It is not
> even possible to 'call' the input where turing machines are concerned.
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<7smdnTa6kZTttgD8nZ2dnUU7-QWdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 11:57:04 -0600
Date: Tue, 23 Nov 2021 11:57:04 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>
<8735nney5m.fsf@bsb.me.uk> <qOednbP80rOnngD8nZ2dnUU7-KXNnZ2d@giganews.com>
<snj6k8$utp$3@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snj6k8$utp$3@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <7smdnTa6kZTttgD8nZ2dnUU7-QWdnZ2d@giganews.com>
Lines: 25
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-szkKXpIALmPL3ZZ7psByZi3FdvZRUAhB9a8K42xGmbEn2njDv5yoPZDC49UxMR/75HzBwoKuCM1yFIn!JgUVxvwfanK71zBC69d5ZT13pP+PVeUAD8S3fKxjcPho0i3CUbtxHO4KHTu8ndBf9ec6SwJ2IBZ7!3A==
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: 2911
 by: olcott - Tue, 23 Nov 2021 17:57 UTC

On 11/23/2021 10:58 AM, André G. Isaak wrote:
> On 2021-11-23 08:05, olcott wrote:
>
>> Thanks again for your superb simplification of my syntax.
>> I knew about the idea of function pointers but didn't know the syntax
>> required to make the simplifications that you provided.
>
> This is a hilarious comment coming from someone who constantly berates
> other people's knowledge of 'software engineering'. Any introductory
> course on programming would cover this.
>
> André
>

The syntax of Coding in C and software engineering are not the same
subject. It could very well be the case that one is a master of the
syntax of C and quite clueless about complex software engineering
interactions.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snjas5$22o$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 11:11:17 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 63
Message-ID: <snjas5$22o$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 18:11:18 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="2136"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/8p2Iki6EVKP/NLqubcno+"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:AbXxLsKCevGRYTL+2iKN15fNYv0=
In-Reply-To: <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 18:11 UTC

On 2021-11-23 10:50, olcott wrote:
> On 11/23/2021 10:54 AM, André G. Isaak wrote:
>> On 2021-11-23 07:59, olcott wrote:
>>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>>> On 2021-11-22 22:42, olcott wrote:
>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>
>>>>>> And that's what the halting problem is about. Determining whether
>>>>>> an independent computation halts. Unless H is part of the input
>>>>>> string why on earth would H be involved in the independent execution?
>>>>>>
>>>>>>> No deciders can actually work that way. All deciders either
>>>>>>> accept or reject finite string inputs.
>>>>>>
>>>>>> And they reject them based on whether the independent computation
>>>>>> described by those strings halt or not. Why would this be a problem?
>>>>>>
>>>>>
>>>>> You can't correctly pass anything to H besides the pair of finite
>>>>> strings or references to the machine language of P.
>>>>>
>>>>> Its inputs are not allowed to have the extra criteria that you
>>>>> assume, thus have no basis to apply it.
>>>>
>>>> Which 'extra criteria'? The inputs to a halt decider are nothing
>>>> more than a finite string exactly as specified in the definition of
>>>> 'halt decider'.
>>>>
>>>> André
>>>>
>>>>
>>>
>>> H is only allowed to have two copies or two references to the machine
>>> code of P as its input corresponding to the finite strings of the TM
>>> description and its input.
>>>
>>> Since this input cannot contain criteria to distinguish its execution
>>> or simulation outside of H from its its execution or simulation by H
>>> anyone that says H must report on the behavior of the execution or
>>> simulation outside of H is incorrect. H is not allowed to know the
>>> difference.
>>
>> There is no "extra criterion" being passed. The halting problem
>> DEFINES exactly what is to be answered, which is whether the
>> *independent* computation represented by the input halts, so the idea
>> that the input would need to somehow specify that the execution is
>> "outside of H" is nonsensical.
>>
>
> You cannot** tell H that it cannot base its halt status decision on its
> own simulation of its input.

No one is telling it that it cannot base its decision on simulation. But
the answer it gives must actually correspond to to the question a halt
decider is required answer, which is concerned with the *independent*
execution of a computation.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snjav5$22o$2@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 11:12:53 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 72
Message-ID: <snjav5$22o$2@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com> <snj6fi$utp$2@dont-email.me>
<7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 18:12:54 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="2136"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+ApvJuGqp8lnbPAOznnoGi"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:/No+4kufcKDANBH5YQQaPa7mwxQ=
In-Reply-To: <7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 18:12 UTC

On 2021-11-23 10:54, olcott wrote:
> On 11/23/2021 10:56 AM, André G. Isaak wrote:
>> On 2021-11-23 08:02, olcott wrote:
>>> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>>>> On 2021-11-22 23:07, olcott wrote:
>>>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>
>>>>>>> And you still haven't actually answered my question:
>>>>>>>
>>>>>>> What does it *mean* for the 'input', something which is not a
>>>>>>> computation, to halt?
>>>>>>>
>>>>>
>>>>> In my first example the input is directly executed so you are still
>>>>> basing your comments on what you think that I must saying instead
>>>>> of what I am actually saying.
>>>>
>>>> Which first example? No examples of anything were given in the post
>>>> you are responding to. And what does 'the input is directly executed
>>>> mean'? The input is a string which cannot be executed at all. You
>>>> mean the
>>>
>>> #include <stdint.h>
>>> #include <stdio.h>
>>> typedef int (*ptr)();
>>>
>>> int H(ptr x, ptr y)
>>> {
>>>    x(y); // direct execution of P(P)
>>>    return 1;
>>> }
>>>
>>> // Minimal essence of Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> int P(ptr x)
>>> {
>>>    H(x, x);
>>>    return 1; // Give P a last instruction at the "c" level
>>> }
>>>
>>> int main(void)
>>> {
>>>    H(P, P);
>>> }
>>>
>>> In the above basis of this whole post H directly invokes P(P).
>>
>> And the above cannot possibly form the basis for a halt decider
>> because there would then be no way to 'abort' the execution of a
>> non-halting input. Your approach depends on the input being simulated.
>>
>
> None-the-less the above conclusively proves that any talk about the
> simulation being incorrect is pure nonsense.

It proves no such thing since by changing the definition of H you have
also changed the definition of P. You are no longer talking about the P
you claim your decider 'correctly' decides.

> When H directly executes its input in the debug step mode of a debugger
> we get the exact same result as when H simulates its input, thus anyone
> saying that the simulation is incorrect is proven wrong.

Executing something inside a debugger is *not* the same thing as the
direct, independent execution of a computation.

André

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<3eanJ.73461$7D4.10664@fx37.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx37.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com> <snj6fi$utp$2@dont-email.me>
<7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 101
Message-ID: <3eanJ.73461$7D4.10664@fx37.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: Tue, 23 Nov 2021 13:16:21 -0500
X-Received-Bytes: 4825
X-Original-Bytes: 4692
 by: Richard Damon - Tue, 23 Nov 2021 18:16 UTC

On 11/23/21 12:54 PM, olcott wrote:
> On 11/23/2021 10:56 AM, André G. Isaak wrote:
>> On 2021-11-23 08:02, olcott wrote:
>>> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>>>> On 2021-11-22 23:07, olcott wrote:
>>>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>
>>>>>>> And you still haven't actually answered my question:
>>>>>>>
>>>>>>> What does it *mean* for the 'input', something which is not a
>>>>>>> computation, to halt?
>>>>>>>
>>>>>
>>>>> In my first example the input is directly executed so you are still
>>>>> basing your comments on what you think that I must saying instead
>>>>> of what I am actually saying.
>>>>
>>>> Which first example? No examples of anything were given in the post
>>>> you are responding to. And what does 'the input is directly executed
>>>> mean'? The input is a string which cannot be executed at all. You
>>>> mean the
>>>
>>> #include <stdint.h>
>>> #include <stdio.h>
>>> typedef int (*ptr)();
>>>
>>> int H(ptr x, ptr y)
>>> {
>>>    x(y); // direct execution of P(P)
>>>    return 1;
>>> }
>>>
>>> // Minimal essence of Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> int P(ptr x)
>>> {
>>>    H(x, x);
>>>    return 1; // Give P a last instruction at the "c" level
>>> }
>>>
>>> int main(void)
>>> {
>>>    H(P, P);
>>> }
>>>
>>> In the above basis of this whole post H directly invokes P(P).
>>
>> And the above cannot possibly form the basis for a halt decider
>> because there would then be no way to 'abort' the execution of a
>> non-halting input. Your approach depends on the input being simulated.
>>
>
> None-the-less the above conclusively proves that any talk about the
> simulation being incorrect is pure nonsense.

The fact that H 'aborts' its simulation, BY DEFINITION, means the
simulation is not a accurate simulation of the input.

PERIOD.

>
> When H directly executes its input in the debug step mode of a debugger
> we get the exact same result as when H simulates its input, thus anyone
> saying that the simulation is incorrect is proven wrong.

'Direct Exectures its input in the debug step mode' is NOT 'Direct
Exection of its input'

FAIL.

The test of correctness is the comparison to the ACTUAL DIRECT EXEUTION
of that input.

ANY deviation, like 'abortting' invalidates the result.

You seem to think you are immortal as you haven't died yet.

Since even YOU agree that when we run P(P) as an independent
computation, it halts, ANY 'equivalent' operation that doesn't do the
same is proved to not be equivalent, and the claim otherwise is a LIE.

Your insistence on this shows that you are a pathological LIAR, and will
suffer the consequences of this.

Your 'Proof' based on this LIE is INVALID and easily seen for the scam
that it is.

You have wasted your life pursuing something you should have known was
all a lie.

>
>> And of course the original problem concerns Turing Machines. It is not
>> even possible to 'call' the input where turing machines are concerned.
>>
>> André
>>
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 12:24:40 -0600
Date: Tue, 23 Nov 2021 12:24:39 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snjas5$22o$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
Lines: 76
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-li7GV/9ELTg/qMJIJpqTTeKYN+E6fO9BORs/FOvZRodlZ/o5+fEfH1+uUWo/TgKBUy3tqvabddt/NkL!IC2040bHsyasdL3scal/Wie0ZJvtkvjPo26BOCcaVigL+Rym2F6NU7BXKm+AaIY0GhrqXvs+/BKu!MA==
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: 4948
 by: olcott - Tue, 23 Nov 2021 18:24 UTC

On 11/23/2021 12:11 PM, André G. Isaak wrote:
> On 2021-11-23 10:50, olcott wrote:
>> On 11/23/2021 10:54 AM, André G. Isaak wrote:
>>> On 2021-11-23 07:59, olcott wrote:
>>>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>>>> On 2021-11-22 22:42, olcott wrote:
>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>
>>>>>>> And that's what the halting problem is about. Determining whether
>>>>>>> an independent computation halts. Unless H is part of the input
>>>>>>> string why on earth would H be involved in the independent
>>>>>>> execution?
>>>>>>>
>>>>>>>> No deciders can actually work that way. All deciders either
>>>>>>>> accept or reject finite string inputs.
>>>>>>>
>>>>>>> And they reject them based on whether the independent computation
>>>>>>> described by those strings halt or not. Why would this be a problem?
>>>>>>>
>>>>>>
>>>>>> You can't correctly pass anything to H besides the pair of finite
>>>>>> strings or references to the machine language of P.
>>>>>>
>>>>>> Its inputs are not allowed to have the extra criteria that you
>>>>>> assume, thus have no basis to apply it.
>>>>>
>>>>> Which 'extra criteria'? The inputs to a halt decider are nothing
>>>>> more than a finite string exactly as specified in the definition of
>>>>> 'halt decider'.
>>>>>
>>>>> André
>>>>>
>>>>>
>>>>
>>>> H is only allowed to have two copies or two references to the
>>>> machine code of P as its input corresponding to the finite strings
>>>> of the TM description and its input.
>>>>
>>>> Since this input cannot contain criteria to distinguish its
>>>> execution or simulation outside of H from its its execution or
>>>> simulation by H anyone that says H must report on the behavior of
>>>> the execution or simulation outside of H is incorrect. H is not
>>>> allowed to know the difference.
>>>
>>> There is no "extra criterion" being passed. The halting problem
>>> DEFINES exactly what is to be answered, which is whether the
>>> *independent* computation represented by the input halts, so the idea
>>> that the input would need to somehow specify that the execution is
>>> "outside of H" is nonsensical.
>>>
>>
>> You cannot** tell H that it cannot base its halt status decision on
>> its own simulation of its input.
>
> No one is telling it that it cannot base its decision on simulation. But
> the answer it gives must actually correspond to to the question a halt
> decider is required answer, which is concerned with the *independent*
> execution of a computation.
>
> André
>
>

That is another way of saying that a decider must base its decision on a
finite string that is not its actual input.

What would the behavior of the input to H(P,P) be if it was not an input
to H(P,P) ???

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<5manJ.70743$Ql5.33354@fx39.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 103
Message-ID: <5manJ.70743$Ql5.33354@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: Tue, 23 Nov 2021 13:24:55 -0500
X-Received-Bytes: 5810
X-Original-Bytes: 5677
 by: Richard Damon - Tue, 23 Nov 2021 18:24 UTC

On 11/23/21 12:50 PM, olcott wrote:
> On 11/23/2021 10:54 AM, André G. Isaak wrote:
>> On 2021-11-23 07:59, olcott wrote:
>>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>>> On 2021-11-22 22:42, olcott wrote:
>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>
>>>>>> And that's what the halting problem is about. Determining whether
>>>>>> an independent computation halts. Unless H is part of the input
>>>>>> string why on earth would H be involved in the independent execution?
>>>>>>
>>>>>>> No deciders can actually work that way. All deciders either
>>>>>>> accept or reject finite string inputs.
>>>>>>
>>>>>> And they reject them based on whether the independent computation
>>>>>> described by those strings halt or not. Why would this be a problem?
>>>>>>
>>>>>
>>>>> You can't correctly pass anything to H besides the pair of finite
>>>>> strings or references to the machine language of P.
>>>>>
>>>>> Its inputs are not allowed to have the extra criteria that you
>>>>> assume, thus have no basis to apply it.
>>>>
>>>> Which 'extra criteria'? The inputs to a halt decider are nothing
>>>> more than a finite string exactly as specified in the definition of
>>>> 'halt decider'.
>>>>
>>>> André
>>>>
>>>>
>>>
>>> H is only allowed to have two copies or two references to the machine
>>> code of P as its input corresponding to the finite strings of the TM
>>> description and its input.
>>>
>>> Since this input cannot contain criteria to distinguish its execution
>>> or simulation outside of H from its its execution or simulation by H
>>> anyone that says H must report on the behavior of the execution or
>>> simulation outside of H is incorrect. H is not allowed to know the
>>> difference.
>>
>> There is no "extra criterion" being passed. The halting problem
>> DEFINES exactly what is to be answered, which is whether the
>> *independent* computation represented by the input halts, so the idea
>> that the input would need to somehow specify that the execution is
>> "outside of H" is nonsensical.
>>
>
> You cannot** tell H that it cannot base its halt status decision on its
> own simulation of its input.

No, it sshould know that.

NO PROGRAM gets its ultimate definition of its task from its input.

The DESIGNER of the program gets the definition of the problem statement
as THEIR input.

Maybe we shouldn't say H was wrong, we should focus more on the fact
that PETER OLCOTT was wrong because he wrote a program that was not
designed to the specification that he took on.

Halting vs Non-Halting: The behavior of the COMPUTATION specifed, either
reaching its final state in a finite number of steps (Halting) or never
reaching such an state in an unbounded number of steps (Non-Halting)

Halt Decider: An algorithm that takes as an input a representation of a
computation, and outputs in finite time a correct indication of the
Halting vs Non-Halting behavior of the computaton that input represents.

You POOP argument is NOT based on this actual definition, but on some
strange idea that instead of looking at the actual behavior of the
computation whose representation you have, you can use another critrea
that differs from it, and get the equivalent answer.

That makes as much sense as listening to a dog to determine the sounds a
cat makes.

>
> **There is no way to say this (in x86 code) and the x86 code of P is
> defined as its correct input equivalent to a TM description.

Right. The error is in the programmer. Peter Olcott was wrong in his
design of H and programmed it to give the wrong answer.

H gave exactly the answer it was programmed to give, it was just given
the wrong orders because Peter Olcott is an idiot and refuses to learn
the meaning of the words in the problem statement.

>
>>> For every input besides pathological inputs the execution or
>>> simulation of the input by H is identical to the execution or
>>> simulation of this same input outside of H.
>>
>> Whatever you might mean by 'execution by H', this is not what the
>> halting problem asks about.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<WfidnVTHgenqrwD8nZ2dnUU7-K2dnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 12:27:02 -0600
Date: Tue, 23 Nov 2021 12:27:02 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com> <snj6fi$utp$2@dont-email.me>
<7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com> <snjav5$22o$2@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snjav5$22o$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <WfidnVTHgenqrwD8nZ2dnUU7-K2dnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VcIUKvj9froW84/MSseup0xvjJsfixj4o/4OGD9uuZN8r/zmyr164lHW0BvbO0N6F9qAA/NOvgTzjQN!tQ1Nz1uLVsBSGgnCzlfd1i0onSOEgukvXZ1AA9EgpeH0ZeDnRwGOFHFbxg0An9uD0oF8I/UiOuMi!iw==
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: 4894
 by: olcott - Tue, 23 Nov 2021 18:27 UTC

On 11/23/2021 12:12 PM, André G. Isaak wrote:
> On 2021-11-23 10:54, olcott wrote:
>> On 11/23/2021 10:56 AM, André G. Isaak wrote:
>>> On 2021-11-23 08:02, olcott wrote:
>>>> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>>>>> On 2021-11-22 23:07, olcott wrote:
>>>>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>
>>>>>>>> And you still haven't actually answered my question:
>>>>>>>>
>>>>>>>> What does it *mean* for the 'input', something which is not a
>>>>>>>> computation, to halt?
>>>>>>>>
>>>>>>
>>>>>> In my first example the input is directly executed so you are
>>>>>> still basing your comments on what you think that I must saying
>>>>>> instead of what I am actually saying.
>>>>>
>>>>> Which first example? No examples of anything were given in the post
>>>>> you are responding to. And what does 'the input is directly
>>>>> executed mean'? The input is a string which cannot be executed at
>>>>> all. You mean the
>>>>
>>>> #include <stdint.h>
>>>> #include <stdio.h>
>>>> typedef int (*ptr)();
>>>>
>>>> int H(ptr x, ptr y)
>>>> {
>>>>    x(y); // direct execution of P(P)
>>>>    return 1;
>>>> }
>>>>
>>>> // Minimal essence of Linz(1990) Ĥ
>>>> // and Strachey(1965) P
>>>> int P(ptr x)
>>>> {
>>>>    H(x, x);
>>>>    return 1; // Give P a last instruction at the "c" level
>>>> }
>>>>
>>>> int main(void)
>>>> {
>>>>    H(P, P);
>>>> }
>>>>
>>>> In the above basis of this whole post H directly invokes P(P).
>>>
>>> And the above cannot possibly form the basis for a halt decider
>>> because there would then be no way to 'abort' the execution of a
>>> non-halting input. Your approach depends on the input being simulated.
>>>
>>
>> None-the-less the above conclusively proves that any talk about the
>> simulation being incorrect is pure nonsense.
>
> It proves no such thing since by changing the definition of H you have
> also changed the definition of P. You are no longer talking about the P
> you claim your decider 'correctly' decides.
>

H is a computable function that accepts or rejects inputs in its domain
on the basis that these inputs specify a sequence of configurations that
reach their final state.

>> When H directly executes its input in the debug step mode of a
>> debugger we get the exact same result as when H simulates its input,
>> thus anyone saying that the simulation is incorrect is proven wrong.
>
> Executing something inside a debugger is *not* the same thing as the
> direct, independent execution of a computation.

It necessarily has the same sequence of configurations.

>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<3oanJ.70744$Ql5.38579@fx39.iad>

 copy mid

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

 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!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<bdc61b53-d765-475b-afc4-a1249c315381n@googlegroups.com>
<8735nney5m.fsf@bsb.me.uk> <qOednbP80rOnngD8nZ2dnUU7-KXNnZ2d@giganews.com>
<snj6k8$utp$3@dont-email.me> <7smdnTa6kZTttgD8nZ2dnUU7-QWdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7smdnTa6kZTttgD8nZ2dnUU7-QWdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 30
Message-ID: <3oanJ.70744$Ql5.38579@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: Tue, 23 Nov 2021 13:27:01 -0500
X-Received-Bytes: 2984
 by: Richard Damon - Tue, 23 Nov 2021 18:27 UTC

On 11/23/21 12:57 PM, olcott wrote:
> On 11/23/2021 10:58 AM, André G. Isaak wrote:
>> On 2021-11-23 08:05, olcott wrote:
>>
>>> Thanks again for your superb simplification of my syntax.
>>> I knew about the idea of function pointers but didn't know the syntax
>>> required to make the simplifications that you provided.
>>
>> This is a hilarious comment coming from someone who constantly berates
>> other people's knowledge of 'software engineering'. Any introductory
>> course on programming would cover this.
>>
>> André
>>
>
> The syntax of Coding in C and software engineering are not the same
> subject. It could very well be the case that one is a master of the
> syntax of C and quite clueless about complex software engineering
> interactions.
>

But you don't seem to understand either, as you don't seem to understand
such fundamentals as requirements.

You aren't a good software engineer, as has been shown.

You aren't a good programmer, as has been shown.

The only thing you seem to be good at is Lying, as you seem to do it a
lot, but maybe you not good at it as people don't believe you.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<xPanJ.93534$ya3.22830@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com> <snj6fi$utp$2@dont-email.me>
<7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com> <snjav5$22o$2@dont-email.me>
<WfidnVTHgenqrwD8nZ2dnUU7-K2dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <WfidnVTHgenqrwD8nZ2dnUU7-K2dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 99
Message-ID: <xPanJ.93534$ya3.22830@fx38.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: Tue, 23 Nov 2021 13:56:18 -0500
X-Received-Bytes: 5342
 by: Richard Damon - Tue, 23 Nov 2021 18:56 UTC

On 11/23/21 1:27 PM, olcott wrote:
> On 11/23/2021 12:12 PM, André G. Isaak wrote:
>> On 2021-11-23 10:54, olcott wrote:
>>> On 11/23/2021 10:56 AM, André G. Isaak wrote:
>>>> On 2021-11-23 08:02, olcott wrote:
>>>>> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>>>>>> On 2021-11-22 23:07, olcott wrote:
>>>>>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>>> And you still haven't actually answered my question:
>>>>>>>>>
>>>>>>>>> What does it *mean* for the 'input', something which is not a
>>>>>>>>> computation, to halt?
>>>>>>>>>
>>>>>>>
>>>>>>> In my first example the input is directly executed so you are
>>>>>>> still basing your comments on what you think that I must saying
>>>>>>> instead of what I am actually saying.
>>>>>>
>>>>>> Which first example? No examples of anything were given in the
>>>>>> post you are responding to. And what does 'the input is directly
>>>>>> executed mean'? The input is a string which cannot be executed at
>>>>>> all. You mean the
>>>>>
>>>>> #include <stdint.h>
>>>>> #include <stdio.h>
>>>>> typedef int (*ptr)();
>>>>>
>>>>> int H(ptr x, ptr y)
>>>>> {
>>>>>    x(y); // direct execution of P(P)
>>>>>    return 1;
>>>>> }
>>>>>
>>>>> // Minimal essence of Linz(1990) Ĥ
>>>>> // and Strachey(1965) P
>>>>> int P(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>>    return 1; // Give P a last instruction at the "c" level
>>>>> }
>>>>>
>>>>> int main(void)
>>>>> {
>>>>>    H(P, P);
>>>>> }
>>>>>
>>>>> In the above basis of this whole post H directly invokes P(P).
>>>>
>>>> And the above cannot possibly form the basis for a halt decider
>>>> because there would then be no way to 'abort' the execution of a
>>>> non-halting input. Your approach depends on the input being simulated.
>>>>
>>>
>>> None-the-less the above conclusively proves that any talk about the
>>> simulation being incorrect is pure nonsense.
>>
>> It proves no such thing since by changing the definition of H you have
>> also changed the definition of P. You are no longer talking about the
>> P you claim your decider 'correctly' decides.
>>
>
> H is a computable function that accepts or rejects inputs in its domain
> on the basis that these inputs specify a sequence of configurations that
> reach their final state.

Except if the definition of 'reach their final state' applies to the
ACTUAL computation, and not the aborted one inside H (as it does), the H
is WRONG because in the case where H(P,P) returns 0, we know that P(P)
will halt, but H(P,P) never reaches that point in its simulation BECAUSE
it aborted its simulation based on unsound logic and returned the wrong
answer, BECAUSE its programmed made an ERROR.

>
>>> When H directly executes its input in the debug step mode of a
>>> debugger we get the exact same result as when H simulates its input,
>>> thus anyone saying that the simulation is incorrect is proven wrong.
>>
>> Executing something inside a debugger is *not* the same thing as the
>> direct, independent execution of a computation.
>
> It necessarily has the same sequence of configurations.

Only if the debugger never aborts the sequence.

Counting 1, 2, 3 (abort) is not the same as 1, 2, 3, 4, 5

If we are testing if we counted to 5, the first implies we did not, but
that was just because the 'debugger' aborted the sequence.

>
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<qVanJ.71297$SW5.29861@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 95
Message-ID: <qVanJ.71297$SW5.29861@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 23 Nov 2021 14:02:35 -0500
X-Received-Bytes: 5678
 by: Richard Damon - Tue, 23 Nov 2021 19:02 UTC

On 11/23/21 1:24 PM, olcott wrote:
> On 11/23/2021 12:11 PM, André G. Isaak wrote:
>> On 2021-11-23 10:50, olcott wrote:
>>> On 11/23/2021 10:54 AM, André G. Isaak wrote:
>>>> On 2021-11-23 07:59, olcott wrote:
>>>>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>>>>> On 2021-11-22 22:42, olcott wrote:
>>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> And that's what the halting problem is about. Determining
>>>>>>>> whether an independent computation halts. Unless H is part of
>>>>>>>> the input string why on earth would H be involved in the
>>>>>>>> independent execution?
>>>>>>>>
>>>>>>>>> No deciders can actually work that way. All deciders either
>>>>>>>>> accept or reject finite string inputs.
>>>>>>>>
>>>>>>>> And they reject them based on whether the independent
>>>>>>>> computation described by those strings halt or not. Why would
>>>>>>>> this be a problem?
>>>>>>>>
>>>>>>>
>>>>>>> You can't correctly pass anything to H besides the pair of finite
>>>>>>> strings or references to the machine language of P.
>>>>>>>
>>>>>>> Its inputs are not allowed to have the extra criteria that you
>>>>>>> assume, thus have no basis to apply it.
>>>>>>
>>>>>> Which 'extra criteria'? The inputs to a halt decider are nothing
>>>>>> more than a finite string exactly as specified in the definition
>>>>>> of 'halt decider'.
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> H is only allowed to have two copies or two references to the
>>>>> machine code of P as its input corresponding to the finite strings
>>>>> of the TM description and its input.
>>>>>
>>>>> Since this input cannot contain criteria to distinguish its
>>>>> execution or simulation outside of H from its its execution or
>>>>> simulation by H anyone that says H must report on the behavior of
>>>>> the execution or simulation outside of H is incorrect. H is not
>>>>> allowed to know the difference.
>>>>
>>>> There is no "extra criterion" being passed. The halting problem
>>>> DEFINES exactly what is to be answered, which is whether the
>>>> *independent* computation represented by the input halts, so the
>>>> idea that the input would need to somehow specify that the execution
>>>> is "outside of H" is nonsensical.
>>>>
>>>
>>> You cannot** tell H that it cannot base its halt status decision on
>>> its own simulation of its input.
>>
>> No one is telling it that it cannot base its decision on simulation.
>> But the answer it gives must actually correspond to to the question a
>> halt decider is required answer, which is concerned with the
>> *independent* execution of a computation.
>>
>> André
>>
>>
>
> That is another way of saying that a decider must base its decision on a
> finite string that is not its actual input.

No, the finite string IS its actual input.

The criteria for a correct answer is based on that same finite string,
but NOT on the behavior of this program, but on another, the real UTM.

To use your window analogy. H is being asked if it is raining outside
the window of UTM, not H. H has the sometimes hard task of trying to
figure out something it can not directly observe.

>
> What would the behavior of the input to H(P,P) be if it was not an input
> to H(P,P) ???
>

The Behavior of the input to H(P,P) would be the same as the behavior of
the input to U(P,P) since we are talking about the behavior of the
INPUT, not the machine has been given to.

It is DEFINED that the ONE machine that has the behavior that is defined
as the 'behavior of the input' is the pure UTM, as the input has been
DEFINED as the representation of a computation, and the definition of a
UTM is that it behaves exactly the same when it simuluates the
representation of a computation as the computation does when run on its own.

FAIL.

Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor