Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Slowly and surely the unix crept up on the Nintendo user ...


devel / comp.theory / Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

SubjectAuthor
* We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
+* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| | `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |`- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |+- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  |`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  | `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  |   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |    `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  |     `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |      `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  |       `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |        `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  |         `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |  |          `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |    `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
| |     `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
| |      `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) -olcott
| |       `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) -Richard Damon
| |        `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) -olcott
| |         `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) -Richard Damon
| |          `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) -immibis
| `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)André G. Isaak
|  +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)immibis
|  |+* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  || `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  ||   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Yaxley Peaks
|  ||    |+- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Mikko
|  ||    | `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Mikko
|  ||    |   +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |   |+* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)immibis
|  ||    |   ||`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |   || +- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  ||    |   || `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)immibis
|  ||    |   ||  `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |   |`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Mikko
|  ||    |   | `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |   |  +- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)immibis
|  ||    |   |  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Mikko
|  ||    |   |   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
|  ||    |   |    +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Mikko
|  ||    |   |    |`* H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesolcott
|  ||    |   |    | +- Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesRichard Damon
|  ||    |   |    | `* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesMikko
|  ||    |   |    |  `* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesolcott
|  ||    |   |    |   +* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesRichard Damon
|  ||    |   |    |   |`* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesolcott
|  ||    |   |    |   | +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsimmibis
|  ||    |   |    |   | |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | | +- Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | | `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsimmibis
|  ||    |   |    |   | |  `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   +* Re: ZFC solution to incorrect questions: reject them --Gödel--immibis
|  ||    |   |    |   | |   |`* Re: ZFC solution to incorrect questions: reject them --Gödel--olcott
|  ||    |   |    |   | |   | `- Re: ZFC solution to incorrect questions: reject them --Gödel--Richard Damon
|  ||    |   |    |   | |   +* Re: ZFC solution to incorrect questions: reject them --Gödel--immibis
|  ||    |   |    |   | |   |`* Re: ZFC solution to incorrect questions: reject them --Gödel--olcott
|  ||    |   |    |   | |   | +* Re: ZFC solution to incorrect questions: reject them --Gödel--Richard Damon
|  ||    |   |    |   | |   | |`- Re: ZFC solution to incorrect questions: reject themolcott
|  ||    |   |    |   | |   | `* Re: ZFC solution to incorrect questions: reject them --Gödel--immibis
|  ||    |   |    |   | |   |  `- Re: ZFC solution to incorrect questions: reject themolcott
|  ||    |   |    |   | |   +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   | +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   | |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   | | `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   | |  `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   | |   +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   | |   |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   | |   | `- Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   | |   `- Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsMikko
|  ||    |   |    |   | |   | `- Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsimmibis
|  ||    |   |    |   | |   +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   | `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   |  `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsolcott
|  ||    |   |    |   | |   |   `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | |   |    `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions olcott
|  ||    |   |    |   | |   |     +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions immibis
|  ||    |   |    |   | |   |     |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions olcott
|  ||    |   |    |   | |   |     | +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions immibis
|  ||    |   |    |   | |   |     | |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions olcott
|  ||    |   |    |   | |   |     | | +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions immibis
|  ||    |   |    |   | |   |     | | |`* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions olcott
|  ||    |   |    |   | |   |     | | | `- Re: Proving my 2004 claim that some decider/input pairs are incorrect questions Mikko
|  ||    |   |    |   | |   |     | | `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions Richard Damon
|  ||    |   |    |   | |   |     | |  `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions olcott
|  ||    |   |    |   | |   |     | |   `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions Richard Damon
|  ||    |   |    |   | |   |     | +* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions Richard Damon
|  ||    |   |    |   | |   |     | `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions Richard Damon
|  ||    |   |    |   | |   |     `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questions Richard Damon
|  ||    |   |    |   | |   `* Re: Proving my 2004 claim that some decider/input pairs are incorrect questionsRichard Damon
|  ||    |   |    |   | `* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesRichard Damon
|  ||    |   |    |   `- Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesMikko
|  ||    |   |    `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  ||    |   +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Mike Terry
|  ||    |   `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  ||    `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  |`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)Richard Damon
|  `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)olcott
`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)immibis

Pages:1234567891011121314
Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi0ej$2d0oc$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 09:49:39 -0600
Organization: A noiseless patient Spider
Lines: 50
Message-ID: <usi0ej$2d0oc$2@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 15:49:39 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="7bba1e21ad186023a2af4b4bf0f27e98";
logging-data="2523916"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19j4sTel0vzA25tgN1rUHfe"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:FQTOoxJQ+iI6U6pGfhisLYlDsXU=
In-Reply-To: <ush8rt$288t1$1@dont-email.me>
Content-Language: en-US
 by: olcott - Sat, 9 Mar 2024 15:49 UTC

On 3/9/2024 3:07 AM, Mikko wrote:
> On 2024-03-08 16:09:58 +0000, olcott said:
>
>> On 3/8/2024 9:29 AM, Mikko wrote:
>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>
>>>> With all of these extra frills, aren't you working outside the premise
>>>> of the halting problem? Like how Andre pointed out.
>>>
>>> Yes, he is.
>>>
>>>> The halting problem concerns itself with turing machines and what you
>>>> propose is not a turing machine.
>>>
>>> That is true. However, we can formulate similar problems and proofs
>>> for other classes of machines.
>>>
>>
>> I am working on the computability of the halting problem
>> (the exact same TMD / input pairs) by a slightly augmented
>> notion of Turing machines as elaborated below:
>>
>> Olcott machines are entirely comprised of a UTM + TMD and one
>> extra step that any UTM could perform, append the TMD to the
>> end of its own tape.
>
> An important question to answer is whether a Turing machine can
> simulate your machines.

Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.

Yes but this machine itself cannot be an Olcott machine. It may or may
not make a difference that this machine cannot be an Olcott machine.

>
> Another interesting question is whether your machines can solve
> their own halting problem.
>

I don't know the details of this yet I do know that the Linz Ĥ
can only fool itself and not any external H. It is also the case
that the Linz machine must either halt or fail to halt and in
either case H ⟨Ĥ⟩ ⟨Ĥ⟩ can see this.

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!69.80.99.22.MISMATCH!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!nntp.brightview.co.uk!news.brightview.co.uk.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 09 Mar 2024 16:06:59 +0000
Subject: Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)
Newsgroups: comp.theory
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org> <usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me> <usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me> <use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me> <use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me> <8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me> <usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
From: news.dea...@darjeeling.plus.com (Mike Terry)
Date: Sat, 9 Mar 2024 16:06:58 +0000
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0 SeaMonkey/2.53.17
MIME-Version: 1.0
In-Reply-To: <ush8rt$288t1$1@dont-email.me>
Content-Type: text/plain; charset=windows-1252; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
Lines: 50
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9Ui7U8Chp4So0OrEvLXUeRMLmK2nn70xqKxcEGXxruXxu5ho8OTQnRpmDaD6MTNokSsnnvvxhSuTJT4!4rlbSG7vd3bM7LpbYugETsihLoK8I9wcQLf/WCQ0kxIUhm8vB3JD7V+CXAMQLWZXr10+Rt8PtgcF!ijVYEqCRnUXo0Dg74nPD3NLjJ7k7
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
 by: Mike Terry - Sat, 9 Mar 2024 16:06 UTC

On 09/03/2024 09:07, Mikko wrote:
> On 2024-03-08 16:09:58 +0000, olcott said:
>
>> On 3/8/2024 9:29 AM, Mikko wrote:
>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>
>>>> With all of these extra frills, aren't you working outside the premise
>>>> of the halting problem? Like how Andre pointed out.
>>>
>>> Yes, he is.
>>>
>>>> The halting problem concerns itself with turing machines and what you
>>>> propose is not a turing machine.
>>>
>>> That is true. However, we can formulate similar problems and proofs
>>> for other classes of machines.
>>>
>>
>> I am working on the computability of the halting problem
>> (the exact same TMD / input pairs) by a slightly augmented
>> notion of Turing machines as elaborated below:
>>
>> Olcott machines are entirely comprised of a UTM + TMD and one
>> extra step that any UTM could perform, append the TMD to the
>> end of its own tape.
>
> An important question to answer is whether a Turing machine can
> simulate your machines.
>
> Another interesting question is whether your machines can solve
> their own halting problem.
>

Since (with just a little thought)
a) a PO-machine can simulate the running of any TM
b) a TM can simulate the running of any PO-machine
that implies that TMs and PO-machines can compute exactly the same functions, and so are equally
powerful. Also it implies PO-machines cannot solve their own halting problem.

PO will surely be disappointed that he cannot add "refuting the Turing-Church thesis" to his list of
impressive refutations. (Although PO would probably not follow or agree with this reasoning, so he
will probably add it anyway...)

The above assumes our definition of TM allows a TM to find the last input symbol on its tape.
That's the case with Linz, since a Linz TM can just search for the first blank character on the
tape. The blank character is not in the input character set.

Mike.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi299$2dc4h$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: new...@immibis.com (immibis)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 17:20:57 +0100
Organization: A noiseless patient Spider
Lines: 60
Message-ID: <usi299$2dc4h$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 16:20:58 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="ebd212445c811809099967b94be0604e";
logging-data="2535569"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18HV2CujHEoomUAEjC4Ft/d"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:IP62ZEfMZr8jFFQUTjihsn5G6Vg=
Content-Language: en-US
In-Reply-To: <usi0ej$2d0oc$2@dont-email.me>
 by: immibis - Sat, 9 Mar 2024 16:20 UTC

On 9/03/24 16:49, olcott wrote:
> On 3/9/2024 3:07 AM, Mikko wrote:
>> On 2024-03-08 16:09:58 +0000, olcott said:
>>
>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>
>>>>> With all of these extra frills, aren't you working outside the premise
>>>>> of the halting problem? Like how Andre pointed out.
>>>>
>>>> Yes, he is.
>>>>
>>>>> The halting problem concerns itself with turing machines and what you
>>>>> propose is not a turing machine.
>>>>
>>>> That is true. However, we can formulate similar problems and proofs
>>>> for other classes of machines.
>>>>
>>>
>>> I am working on the computability of the halting problem
>>> (the exact same TMD / input pairs) by a slightly augmented
>>> notion of Turing machines as elaborated below:
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the
>>> end of its own tape.
>>
>> An important question to answer is whether a Turing machine can
>> simulate your machines.
>
> Olcott machines are entirely comprised of a UTM + TMD and one
> extra step that any UTM could perform, append the TMD to the end
> of its own tape.
>
> Yes but this machine itself cannot be an Olcott machine. It may or may
> not make a difference that this machine cannot be an Olcott machine.

It can, because any Turing machine can be an Olcott machine if it simply
ignores the machine description appended to its tape.

And any Olcott machine can become a Turing machine if you bundle it
together with a UTM that appends the description to the tape.

These show that every function that can be computed with an Olcott
machine can be computed with a Turing machine, and every function that
can be computed with a Turing machine can be computed with an Olcott
machine. If an Olcott machine can compute the Olcott halting function,
so can a Turing machine.

>> Another interesting question is whether your machines can solve
>> their own halting problem.
>>
>
> I don't know the details of this yet I do know that the Linz Ĥ
> can only fool itself and not any external H.

The Linz Ĥ is defined so that it always calculates the same result as H.
You tried to subvert this by inventing Olcott machines, but it doesn't
work. Any claim based on the fact that Ĥ calculates a different result
from H is dishonest.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi31g$2dklj$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 10:33:51 -0600
Organization: A noiseless patient Spider
Lines: 98
Message-ID: <usi31g$2dklj$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 16:33:52 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="7bba1e21ad186023a2af4b4bf0f27e98";
logging-data="2544307"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19mFDVxCSYQFWH0GrcObNKS"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:7qm5Q7WAsU/t7jJebHMWbZi5LQM=
Content-Language: en-US
In-Reply-To: <EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
 by: olcott - Sat, 9 Mar 2024 16:33 UTC

On 3/9/2024 10:06 AM, Mike Terry wrote:
> On 09/03/2024 09:07, Mikko wrote:
>> On 2024-03-08 16:09:58 +0000, olcott said:
>>
>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>
>>>>> With all of these extra frills, aren't you working outside the premise
>>>>> of the halting problem? Like how Andre pointed out.
>>>>
>>>> Yes, he is.
>>>>
>>>>> The halting problem concerns itself with turing machines and what you
>>>>> propose is not a turing machine.
>>>>
>>>> That is true. However, we can formulate similar problems and proofs
>>>> for other classes of machines.
>>>>
>>>
>>> I am working on the computability of the halting problem
>>> (the exact same TMD / input pairs) by a slightly augmented
>>> notion of Turing machines as elaborated below:
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the
>>> end of its own tape.
>>
>> An important question to answer is whether a Turing machine can
>> simulate your machines.
>>
>> Another interesting question is whether your machines can solve
>> their own halting problem.
>>
>
> Since (with just a little thought)
> a)  a PO-machine can simulate the running of any TM
> b)  a TM can simulate the running of any PO-machine
> that implies that TMs and PO-machines can compute exactly the same
> functions, and so are equally powerful.

Thanks for your review.

Yes I agree with this now.
The only possible caveat is that Turing Machine simulating an
Olcott machine doing this cannot itself be an Olcott machine.

This seems probably moot. I cannot correctly determine that it
<is> moot without a categorically exhaustive complete search.

> Also it implies PO-machines
> cannot solve their own halting problem.
>

*I don't think so*
It may still be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
compute *Criterion Measure* This by itself provides the basis
for a Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly transition to H.qy.

*Criterion Measure*
*Determine halt status from simulating halt deciders POV*
H is assumed to be a simulating termination analyzer that aborts the
simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.

> PO will surely be disappointed that he cannot add "refuting the
> Turing-Church thesis" to his list of impressive refutations.  (Although
> PO would probably not follow or agree with this reasoning, so he will
> probably add it anyway...)
>

You provided no reasoning to support your claim and I did provide
reasoning to possibly rebut whatever your reasoning might be.
If TM's can compute *Criterion Measure* then Olcott machines are
not needed.

> The above assumes our definition of TM allows a TM to find the last
> input symbol on its tape. That's the case with Linz, since a Linz TM can
> just search for the first blank character on the tape.  The blank
> character is not in the input character set.
>

If a TM has more than one input this will not work so I
extended this protocol to allow multiple inputs and
a final input that can be ignored.

All inputs are followed by a single space. The last conventional
input is followed by four spaces. The TMD of the machine being
simulated is appended after this followed by four spaces. This
enables machines to use or ignore their own TMD.

>
> Mike.
>

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi3n4$2dk9m$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: new...@immibis.com (immibis)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 17:45:24 +0100
Organization: A noiseless patient Spider
Lines: 84
Message-ID: <usi3n4$2dk9m$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
<usi31g$2dklj$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 16:45:24 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="ebd212445c811809099967b94be0604e";
logging-data="2543926"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18O3YgHEiLuIwAxCp3jf05R"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:S0Xt8/cMGehtMyffcLbQ4ntDGDk=
Content-Language: en-US
In-Reply-To: <usi31g$2dklj$1@dont-email.me>
 by: immibis - Sat, 9 Mar 2024 16:45 UTC

On 9/03/24 17:33, olcott wrote:
> On 3/9/2024 10:06 AM, Mike Terry wrote:
>> On 09/03/2024 09:07, Mikko wrote:
>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>
>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>
>>>>>> With all of these extra frills, aren't you working outside the
>>>>>> premise
>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>
>>>>> Yes, he is.
>>>>>
>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>> propose is not a turing machine.
>>>>>
>>>>> That is true. However, we can formulate similar problems and proofs
>>>>> for other classes of machines.
>>>>>
>>>>
>>>> I am working on the computability of the halting problem
>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>> notion of Turing machines as elaborated below:
>>>>
>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>> extra step that any UTM could perform, append the TMD to the
>>>> end of its own tape.
>>>
>>> An important question to answer is whether a Turing machine can
>>> simulate your machines.
>>>
>>> Another interesting question is whether your machines can solve
>>> their own halting problem.
>>>
>>
>> Since (with just a little thought)
>> a)  a PO-machine can simulate the running of any TM
>> b)  a TM can simulate the running of any PO-machine
>> that implies that TMs and PO-machines can compute exactly the same
>> functions, and so are equally powerful.
>
> Thanks for your review.
>
> Yes I agree with this now.
> The only possible caveat is that Turing Machine simulating an
> Olcott machine doing this cannot itself be an Olcott machine.

Any Turing Machine can be converted to an Olcott Machine if it just
deletes the extra input at the beginning before it does whatever it does.

>> Also it implies PO-machines cannot solve their own halting problem.
>
> *I don't think so*
> It may still be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
> compute *Criterion Measure* This by itself provides the basis
> for a Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly transition to H.qy.
>
> *Criterion Measure*
> *Determine halt status from simulating halt deciders POV*
> H is assumed to be a simulating termination analyzer that aborts the
> simulation of any input that would cause its own non-termination and
> returns NO. Otherwise H always returns YES.

NO is the wrong answer for that input because that input does halt. Your
halt decider accidentally aborts inputs that do terminate or it
accidentally does not abort inputs that do not terminate. It is
impossible for a simulating halt decider to not make at least one of
these mistakes (possibly both).

>> The above assumes our definition of TM allows a TM to find the last
>> input symbol on its tape. That's the case with Linz, since a Linz TM
>> can just search for the first blank character on the tape.  The blank
>> character is not in the input character set.
>>
>
> If a TM has more than one input this will not work so I
> extended this protocol to allow multiple inputs and
> a final input that can be ignored.

As long as we all agree the TM has some way to know the beginning and
end of each input (such as a special separator/space symbol and possibly
an end-of-tape symbol), there is no problem and Mike is just being
overly pedantic.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi43d$2dklj$4@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 10:51:57 -0600
Organization: A noiseless patient Spider
Lines: 91
Message-ID: <usi43d$2dklj$4@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usi299$2dc4h$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 16:51:58 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="7bba1e21ad186023a2af4b4bf0f27e98";
logging-data="2544307"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18j58ZKwgsDUJabXtag8Gdl"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Gn/LcmEFyLShU+A4pxQJp2rLeUE=
In-Reply-To: <usi299$2dc4h$1@dont-email.me>
Content-Language: en-US
 by: olcott - Sat, 9 Mar 2024 16:51 UTC

On 3/9/2024 10:20 AM, immibis wrote:
> On 9/03/24 16:49, olcott wrote:
>> On 3/9/2024 3:07 AM, Mikko wrote:
>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>
>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>
>>>>>> With all of these extra frills, aren't you working outside the
>>>>>> premise
>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>
>>>>> Yes, he is.
>>>>>
>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>> propose is not a turing machine.
>>>>>
>>>>> That is true. However, we can formulate similar problems and proofs
>>>>> for other classes of machines.
>>>>>
>>>>
>>>> I am working on the computability of the halting problem
>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>> notion of Turing machines as elaborated below:
>>>>
>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>> extra step that any UTM could perform, append the TMD to the
>>>> end of its own tape.
>>>
>>> An important question to answer is whether a Turing machine can
>>> simulate your machines.
>>
>> Olcott machines are entirely comprised of a UTM + TMD and one
>> extra step that any UTM could perform, append the TMD to the end
>> of its own tape.
>>
>> Yes but this machine itself cannot be an Olcott machine. It may or may
>> not make a difference that this machine cannot be an Olcott machine.
>
> It can, because any Turing machine can be an Olcott machine if it simply
> ignores the machine description appended to its tape.

If the Turing machine that is not an Olcott machine can somehow
be fooled because it is not an Olcott machine then Turing machines
are not equivalent to Olcott machines, otherwise they are.

> And any Olcott machine can become a Turing machine if you bundle it
> together with a UTM that appends the description to the tape.
>

Yet equivalence might require every Turing machine to become an
Olcott machine and the outermost Turing machine cannot do this.

> These show that every function that can be computed with an Olcott
> machine can be computed with a Turing machine, and every function that
> can be computed with a Turing machine can be computed with an Olcott
> machine.

It may be the case that the outermost Turing machine that cannot
be an Olcott machine can be stumped on some input that an Olcott
machine could compute.

> If an Olcott machine can compute the Olcott halting function,
> so can a Turing machine.

Not necessarily.

>>> Another interesting question is whether your machines can solve
>>> their own halting problem.
>>>
>>
>> I don't know the details of this yet I do know that the Linz Ĥ
>> can only fool itself and not any external H.
>
> The Linz Ĥ is defined so that it always calculates the same result as H.

Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort
its simulation and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation and in theory
these behaviors cannot possibly diverge. Verified facts do supersede
all theories to the contrary.

> You tried to subvert this by inventing Olcott machines, but it doesn't
> work. Any claim based on the fact that Ĥ calculates a different result
> from H is dishonest.

*Verified facts do supersede all theories to the contrary*

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi5ju$1bb6n$4@i2pn2.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!.POSTED!not-for-mail
From: rich...@damon-family.org (Richard Damon)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 09:17:44 -0800
Organization: i2pn2 (i2pn.org)
Message-ID: <usi5ju$1bb6n$4@i2pn2.org>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sat, 9 Mar 2024 17:17:53 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1420503"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <ush8rt$288t1$1@dont-email.me>
Content-Language: en-US
 by: Richard Damon - Sat, 9 Mar 2024 17:17 UTC

On 3/9/24 1:07 AM, Mikko wrote:
> On 2024-03-08 16:09:58 +0000, olcott said:
>
>> On 3/8/2024 9:29 AM, Mikko wrote:
>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>
>>>> With all of these extra frills, aren't you working outside the premise
>>>> of the halting problem? Like how Andre pointed out.
>>>
>>> Yes, he is.
>>>
>>>> The halting problem concerns itself with turing machines and what you
>>>> propose is not a turing machine.
>>>
>>> That is true. However, we can formulate similar problems and proofs
>>> for other classes of machines.
>>>
>>
>> I am working on the computability of the halting problem
>> (the exact same TMD / input pairs) by a slightly augmented
>> notion of Turing machines as elaborated below:
>>
>> Olcott machines are entirely comprised of a UTM + TMD and one
>> extra step that any UTM could perform, append the TMD to the
>> end of its own tape.
>
> An important question to answer is whether a Turing machine can
> simulate your machines.
>
> Another interesting question is whether your machines can solve
> their own halting problem.
>

Since they are DEFINED to be run by an ordinary UTM that just copies the
machine description from the UTMs tape into the simulated machines
virtual tape, which a something a Turing Machine can do.

By DEFINITION, Turing Machines can simulate his machines, thus can do
anything they can do.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi63b$2e7ob$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 11:26:03 -0600
Organization: A noiseless patient Spider
Lines: 110
Message-ID: <usi63b$2e7ob$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
<usi31g$2dklj$1@dont-email.me> <usi3n4$2dk9m$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 17:26:04 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="7bba1e21ad186023a2af4b4bf0f27e98";
logging-data="2563851"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18+ZWD9m9O18ixsJElyFJN2"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:7MV7xpViahM9SUfbbCM0BB9Cb7w=
In-Reply-To: <usi3n4$2dk9m$1@dont-email.me>
Content-Language: en-US
 by: olcott - Sat, 9 Mar 2024 17:26 UTC

On 3/9/2024 10:45 AM, immibis wrote:
> On 9/03/24 17:33, olcott wrote:
>> On 3/9/2024 10:06 AM, Mike Terry wrote:
>>> On 09/03/2024 09:07, Mikko wrote:
>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>
>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>
>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>> premise
>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>
>>>>>> Yes, he is.
>>>>>>
>>>>>>> The halting problem concerns itself with turing machines and what
>>>>>>> you
>>>>>>> propose is not a turing machine.
>>>>>>
>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>> for other classes of machines.
>>>>>>
>>>>>
>>>>> I am working on the computability of the halting problem
>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>> notion of Turing machines as elaborated below:
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the
>>>>> end of its own tape.
>>>>
>>>> An important question to answer is whether a Turing machine can
>>>> simulate your machines.
>>>>
>>>> Another interesting question is whether your machines can solve
>>>> their own halting problem.
>>>>
>>>
>>> Since (with just a little thought)
>>> a)  a PO-machine can simulate the running of any TM
>>> b)  a TM can simulate the running of any PO-machine
>>> that implies that TMs and PO-machines can compute exactly the same
>>> functions, and so are equally powerful.
>>
>> Thanks for your review.
>>
>> Yes I agree with this now.
>> The only possible caveat is that Turing Machine simulating an
>> Olcott machine doing this cannot itself be an Olcott machine.
>
> Any Turing Machine can be converted to an Olcott Machine if it just
> deletes the extra input at the beginning before it does whatever it does.

Wrong you are doing the conversion backwards.
That is how you convert an Olcott machine into a Turing machine.

>
>>> Also it implies PO-machines cannot solve their own halting problem.
>>
>> *I don't think so*
>> It may still be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
>> compute *Criterion Measure* This by itself provides the basis
>> for a Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly transition to H.qy.
>>
>> *Criterion Measure*
>> *Determine halt status from simulating halt deciders POV*
>> H is assumed to be a simulating termination analyzer that aborts the
>> simulation of any input that would cause its own non-termination and
>> returns NO. Otherwise H always returns YES.
>
> NO is the wrong answer for that input because that input does halt. Your
> halt decider accidentally aborts inputs that do terminate or it
> accidentally does not abort inputs that do not terminate. It is
> impossible for a simulating halt decider to not make at least one of
> these mistakes (possibly both).
>

It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
and verified facts supersede all theories to the contrary.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

>>> The above assumes our definition of TM allows a TM to find the last
>>> input symbol on its tape. That's the case with Linz, since a Linz TM
>>> can just search for the first blank character on the tape.  The blank
>>> character is not in the input character set.
>>>
>>
>> If a TM has more than one input this will not work so I
>> extended this protocol to allow multiple inputs and
>> a final input that can be ignored.
>
> As long as we all agree the TM has some way to know the beginning and
> end of each input (such as a special separator/space symbol and possibly
> an end-of-tape symbol), there is no problem and Mike is just being
> overly pedantic.

At least on this one point.

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi675$1bb6n$5@i2pn2.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!.POSTED!not-for-mail
From: rich...@damon-family.org (Richard Damon)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 09:28:02 -0800
Organization: i2pn2 (i2pn.org)
Message-ID: <usi675$1bb6n$5@i2pn2.org>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usi299$2dc4h$1@dont-email.me>
<usi43d$2dklj$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 17:28:06 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1420503"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
In-Reply-To: <usi43d$2dklj$4@dont-email.me>
 by: Richard Damon - Sat, 9 Mar 2024 17:28 UTC

On 3/9/24 8:51 AM, olcott wrote:
> On 3/9/2024 10:20 AM, immibis wrote:
>> On 9/03/24 16:49, olcott wrote:
>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>
>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>
>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>> premise
>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>
>>>>>> Yes, he is.
>>>>>>
>>>>>>> The halting problem concerns itself with turing machines and what
>>>>>>> you
>>>>>>> propose is not a turing machine.
>>>>>>
>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>> for other classes of machines.
>>>>>>
>>>>>
>>>>> I am working on the computability of the halting problem
>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>> notion of Turing machines as elaborated below:
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the
>>>>> end of its own tape.
>>>>
>>>> An important question to answer is whether a Turing machine can
>>>> simulate your machines.
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the end
>>> of its own tape.
>>>
>>> Yes but this machine itself cannot be an Olcott machine. It may or may
>>> not make a difference that this machine cannot be an Olcott machine.
>>
>> It can, because any Turing machine can be an Olcott machine if it
>> simply ignores the machine description appended to its tape.
>
> If the Turing machine that is not an Olcott machine can somehow
> be fooled because it is not an Olcott machine then Turing machines
> are not equivalent to Olcott machines, otherwise they are.

That just says you used the wrong Turing Machine.

You don't seem to understand the property of "Equivalence"

>
>> And any Olcott machine can become a Turing machine if you bundle it
>> together with a UTM that appends the description to the tape.
>>
>
> Yet equivalence might require every Turing machine to become an
> Olcott machine and the outermost Turing machine cannot do this.

No, we show that for ANY computation that you ask of a Olcott Machine,
we can make a Turing machine that does the same thing.

You have your relationship backwards (as seems normal for you). To show
that Turing Machine can do everythinng an Olcott machine can do, you
need to show that for every OLCOTT Machine, you can make an equivalent
TURING Machine.

To do this, you just need to make that Master UTM as a Turing Machine,
which you agree is possible, then give it the description of the Olcott
machine and its input.

>
>> These show that every function that can be computed with an Olcott
>> machine can be computed with a Turing machine, and every function that
>> can be computed with a Turing machine can be computed with an Olcott
>> machine.
>
> It may be the case that the outermost Turing machine that cannot
> be an Olcott machine can be stumped on some input that an Olcott
> machine could compute.

That statement doesn't make sense. At best that says that there may be
some Turing Machines that can not be made into Olcott Machines which
makes them not a Turing Complete system of Computation.

>
>> If an Olcott machine can compute the Olcott halting function, so can a
>> Turing machine.
>
> Not necessarily.

Since it is shown that ALL Olcott machines have an exact equivaent
computation in a Turing Machine, it does.

>
>>>> Another interesting question is whether your machines can solve
>>>> their own halting problem.
>>>>
>>>
>>> I don't know the details of this yet I do know that the Linz Ĥ
>>> can only fool itself and not any external H.
>>
>> The Linz Ĥ is defined so that it always calculates the same result as H.
>
> Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort
> its simulation and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation and in theory
> these behaviors cannot possibly diverge. Verified facts do supersede
> all theories to the contrary.

No, it must aborts its simulation to meet its requirements. It might
not, and then just not meet its requirements.

If you presume that it DOES, but it can't, then you just proved that
none of these machine (that meet the requirements) actually exist.

>
>> You tried to subvert this by inventing Olcott machines, but it doesn't
>> work. Any claim based on the fact that Ĥ calculates a different result
>> from H is dishonest.
>
> *Verified facts do supersede all theories to the contrary*
>

Yes, but you need to actually VERIFY them, and not work on PRESUMPTIONS.

Your whole argument begins with, ASSUMING THAT SUCH AN H Exists.

Thus, NOTHING is VERIFIED until you prove that assumption, which you can't.

You can presume a fact to prove it wrong, that is proof by contradiction.

You can not presume a fact to prove it right, that is just fallacy.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usi6ar$1bb6n$6@i2pn2.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!.POSTED!not-for-mail
From: rich...@damon-family.org (Richard Damon)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 09:30:00 -0800
Organization: i2pn2 (i2pn.org)
Message-ID: <usi6ar$1bb6n$6@i2pn2.org>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
<usi31g$2dklj$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 17:30:04 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1420503"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <usi31g$2dklj$1@dont-email.me>
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
 by: Richard Damon - Sat, 9 Mar 2024 17:30 UTC

On 3/9/24 8:33 AM, olcott wrote:
> On 3/9/2024 10:06 AM, Mike Terry wrote:
>> On 09/03/2024 09:07, Mikko wrote:
>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>
>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>
>>>>>> With all of these extra frills, aren't you working outside the
>>>>>> premise
>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>
>>>>> Yes, he is.
>>>>>
>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>> propose is not a turing machine.
>>>>>
>>>>> That is true. However, we can formulate similar problems and proofs
>>>>> for other classes of machines.
>>>>>
>>>>
>>>> I am working on the computability of the halting problem
>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>> notion of Turing machines as elaborated below:
>>>>
>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>> extra step that any UTM could perform, append the TMD to the
>>>> end of its own tape.
>>>
>>> An important question to answer is whether a Turing machine can
>>> simulate your machines.
>>>
>>> Another interesting question is whether your machines can solve
>>> their own halting problem.
>>>
>>
>> Since (with just a little thought)
>> a)  a PO-machine can simulate the running of any TM
>> b)  a TM can simulate the running of any PO-machine
>> that implies that TMs and PO-machines can compute exactly the same
>> functions, and so are equally powerful.
>
> Thanks for your review.
>
> Yes I agree with this now.
> The only possible caveat is that Turing Machine simulating an
> Olcott machine doing this cannot itself be an Olcott machine.
>
> This seems probably moot. I cannot correctly determine that it
> <is> moot without a categorically exhaustive complete search.
>
>> Also it implies PO-machines cannot solve their own halting problem.
>>
>
> *I don't think so*
> It may still be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
> compute *Criterion Measure* This by itself provides the basis
> for a Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly transition to H.qy.
>
> *Criterion Measure*
> *Determine halt status from simulating halt deciders POV*
> H is assumed to be a simulating termination analyzer that aborts the
> simulation of any input that would cause its own non-termination and
> returns NO. Otherwise H always returns YES.
>
>> PO will surely be disappointed that he cannot add "refuting the
>> Turing-Church thesis" to his list of impressive refutations.
>> (Although PO would probably not follow or agree with this reasoning,
>> so he will probably add it anyway...)
>>
>
> You provided no reasoning to support your claim and I did provide
> reasoning to possibly rebut whatever your reasoning might be.
> If TM's can compute *Criterion Measure* then Olcott machines are
> not needed.
>
>> The above assumes our definition of TM allows a TM to find the last
>> input symbol on its tape. That's the case with Linz, since a Linz TM
>> can just search for the first blank character on the tape.  The blank
>> character is not in the input character set.
>>
>
> If a TM has more than one input this will not work so I
> extended this protocol to allow multiple inputs and
> a final input that can be ignored.
>
> All inputs are followed by a single space. The last conventional
> input is followed by four spaces. The TMD of the machine being
> simulated is appended after this followed by four spaces. This
> enables machines to use or ignore their own TMD.
>
>>
>> Mike.
>>
>

Which since your Criterion Measure isn't the Criteria of Halting, proves
NOTHING about the Halting Problem.

You can't prove details about Cats by talking about Office Buildings.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usihui$2gn6l$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: new...@immibis.com (immibis)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 21:48:18 +0100
Organization: A noiseless patient Spider
Lines: 103
Message-ID: <usihui$2gn6l$2@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usi299$2dc4h$1@dont-email.me>
<usi43d$2dklj$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 20:48:18 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="84f18222dde37498e0174c3433c1390b";
logging-data="2645205"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18iV/XohRaOPyFukcYjpBBM"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Nof++BsWGbzEnRMzBv2zCfIXBWo=
Content-Language: en-US
In-Reply-To: <usi43d$2dklj$4@dont-email.me>
 by: immibis - Sat, 9 Mar 2024 20:48 UTC

On 9/03/24 17:51, olcott wrote:
> On 3/9/2024 10:20 AM, immibis wrote:
>> On 9/03/24 16:49, olcott wrote:
>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>
>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>
>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>> premise
>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>
>>>>>> Yes, he is.
>>>>>>
>>>>>>> The halting problem concerns itself with turing machines and what
>>>>>>> you
>>>>>>> propose is not a turing machine.
>>>>>>
>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>> for other classes of machines.
>>>>>>
>>>>>
>>>>> I am working on the computability of the halting problem
>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>> notion of Turing machines as elaborated below:
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the
>>>>> end of its own tape.
>>>>
>>>> An important question to answer is whether a Turing machine can
>>>> simulate your machines.
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the end
>>> of its own tape.
>>>
>>> Yes but this machine itself cannot be an Olcott machine. It may or may
>>> not make a difference that this machine cannot be an Olcott machine.
>>
>> It can, because any Turing machine can be an Olcott machine if it
>> simply ignores the machine description appended to its tape.
>
> If the Turing machine that is not an Olcott machine can somehow
> be fooled because it is not an Olcott machine then Turing machines
> are not equivalent to Olcott machines, otherwise they are.

The Turing machine and the Olcott machine always get exactly the same
answer as each other. If it's the wrong answer, then it's the wrong
answer for both of them.

>> And any Olcott machine can become a Turing machine if you bundle it
>> together with a UTM that appends the description to the tape.
>
> Yet equivalence might require every Turing machine to become an
> Olcott machine and the outermost Turing machine cannot do this.

Yes it can. It just has to delete the extra machine description before
it does anything else.

>> These show that every function that can be computed with an Olcott
>> machine can be computed with a Turing machine, and every function that
>> can be computed with a Turing machine can be computed with an Olcott
>> machine.
>
> It may be the case that the outermost Turing machine that cannot
> be an Olcott machine can be stumped on some input that an Olcott
> machine could compute.

This has not been verified. It has been verified that every Turing
machine can be converted to an Olcott machine by . It has been verified
that the Turing machine and the Olcott machine always leave the exact
same outputs on their tape when they halt, and if they do not halt, they
do not halt under exactly the same conditions.

>> If an Olcott machine can compute the Olcott halting function, so can a
>> Turing machine.
>
> Not necessarily.

Yes necessarily - see above.

>>>> Another interesting question is whether your machines can solve
>>>> their own halting problem.
>>>>
>>>
>>> I don't know the details of this yet I do know that the Linz Ĥ
>>> can only fool itself and not any external H.
>>
>> The Linz Ĥ is defined so that it always calculates the same result as H.
>
> Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort
> its simulation and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation and in theory
> these behaviors cannot possibly diverge. Verified facts do supersede
> all theories to the contrary.

Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and H ⟨Ĥ⟩
⟨Ĥ⟩ <H> both compute exactly the same answer. Regardless of what it
"must" do, it is a verified fact that what it ACTUALLY does is opposite
to what it "must" do. Verified facts do supersede all theories to the
contrary.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usii3u$2gn6l$4@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: new...@immibis.com (immibis)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 21:51:10 +0100
Organization: A noiseless patient Spider
Lines: 25
Message-ID: <usii3u$2gn6l$4@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
<usi31g$2dklj$1@dont-email.me> <usi3n4$2dk9m$1@dont-email.me>
<usi63b$2e7ob$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 20:51:11 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="84f18222dde37498e0174c3433c1390b";
logging-data="2645205"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+VWCikwvh24KQifRum0aJM"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:aSktAvltdVu7IODRVpF1Z7LmEBI=
In-Reply-To: <usi63b$2e7ob$1@dont-email.me>
Content-Language: en-US
 by: immibis - Sat, 9 Mar 2024 20:51 UTC

On 9/03/24 18:26, olcott wrote:
> On 3/9/2024 10:45 AM, immibis wrote:
>> Any Turing Machine can be converted to an Olcott Machine if it just
>> deletes the extra input at the beginning before it does whatever it does.
>
> Wrong you are doing the conversion backwards.
> That is how you convert an Olcott machine into a Turing machine.

Wrong I am doing the conversion the right way. You are doing it
backwards. To convert an Olcott machine into a Turing machine you need
to insert the code which adds the machine description to the tape.

>> NO is the wrong answer for that input because that input does halt.
>> Your halt decider accidentally aborts inputs that do terminate or it
>> accidentally does not abort inputs that do not terminate. It is
>> impossible for a simulating halt decider to not make at least one of
>> these mistakes (possibly both).
>>
>
> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
> and verified facts supersede all theories to the contrary.

It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ actually does the opposite of
what it must do, so it's wrong.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usiiqq$2gnhr$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 15:03:22 -0600
Organization: A noiseless patient Spider
Lines: 112
Message-ID: <usiiqq$2gnhr$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usi299$2dc4h$1@dont-email.me>
<usi43d$2dklj$4@dont-email.me> <usihui$2gn6l$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 21:03:22 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="7bba1e21ad186023a2af4b4bf0f27e98";
logging-data="2645563"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX198CokpPx25V1gTokQh2/cI"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:pjIo7yvEcaSvuPudkZ+rroegJ1o=
Content-Language: en-US
In-Reply-To: <usihui$2gn6l$2@dont-email.me>
 by: olcott - Sat, 9 Mar 2024 21:03 UTC

On 3/9/2024 2:48 PM, immibis wrote:
> On 9/03/24 17:51, olcott wrote:
>> On 3/9/2024 10:20 AM, immibis wrote:
>>> On 9/03/24 16:49, olcott wrote:
>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>
>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>
>>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>>> premise
>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>
>>>>>>> Yes, he is.
>>>>>>>
>>>>>>>> The halting problem concerns itself with turing machines and
>>>>>>>> what you
>>>>>>>> propose is not a turing machine.
>>>>>>>
>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>> for other classes of machines.
>>>>>>>
>>>>>>
>>>>>> I am working on the computability of the halting problem
>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>> notion of Turing machines as elaborated below:
>>>>>>
>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>> end of its own tape.
>>>>>
>>>>> An important question to answer is whether a Turing machine can
>>>>> simulate your machines.
>>>>
>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>> extra step that any UTM could perform, append the TMD to the end
>>>> of its own tape.
>>>>
>>>> Yes but this machine itself cannot be an Olcott machine. It may or may
>>>> not make a difference that this machine cannot be an Olcott machine.
>>>
>>> It can, because any Turing machine can be an Olcott machine if it
>>> simply ignores the machine description appended to its tape.
>>
>> If the Turing machine that is not an Olcott machine can somehow
>> be fooled because it is not an Olcott machine then Turing machines
>> are not equivalent to Olcott machines, otherwise they are.
>
> The Turing machine and the Olcott machine always get exactly the same
> answer as each other. If it's the wrong answer, then it's the wrong
> answer for both of them.
>
>>> And any Olcott machine can become a Turing machine if you bundle it
>>> together with a UTM that appends the description to the tape.
>>
>> Yet equivalence might require every Turing machine to become an
>> Olcott machine and the outermost Turing machine cannot do this.
>
> Yes it can. It just has to delete the extra machine description before
> it does anything else.
>
>>> These show that every function that can be computed with an Olcott
>>> machine can be computed with a Turing machine, and every function
>>> that can be computed with a Turing machine can be computed with an
>>> Olcott machine.
>>
>> It may be the case that the outermost Turing machine that cannot
>> be an Olcott machine can be stumped on some input that an Olcott
>> machine could compute.
>
> This has not been verified. It has been verified that every Turing
> machine can be converted to an Olcott machine by . It has been verified
> that the Turing machine and the Olcott machine always leave the exact
> same outputs on their tape when they halt, and if they do not halt, they
> do not halt under exactly the same conditions.
>
>>> If an Olcott machine can compute the Olcott halting function, so can
>>> a Turing machine.
>>
>> Not necessarily.
>
> Yes necessarily - see above.
>
>>>>> Another interesting question is whether your machines can solve
>>>>> their own halting problem.
>>>>>
>>>>
>>>> I don't know the details of this yet I do know that the Linz Ĥ
>>>> can only fool itself and not any external H.
>>>
>>> The Linz Ĥ is defined so that it always calculates the same result as H.
>>
>> Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort
>> its simulation and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation and in theory
>> these behaviors cannot possibly diverge. Verified facts do supersede
>> all theories to the contrary.
>
> Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and H ⟨Ĥ⟩
> ⟨Ĥ⟩ <H> both compute exactly the same answer. Regardless of what it
> "must" do, it is a verified fact that what it ACTUALLY does is opposite
> to what it "must" do. Verified facts do supersede all theories to the
> contrary.
>

*Please see my new post that explains these things more clearly*
[Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usiitq$2gnhr$3@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sat, 9 Mar 2024 15:04:57 -0600
Organization: A noiseless patient Spider
Lines: 35
Message-ID: <usiitq$2gnhr$3@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<EoycndFU4O65FHH4nZ2dnZfqn_GdnZ2d@brightview.co.uk>
<usi31g$2dklj$1@dont-email.me> <usi3n4$2dk9m$1@dont-email.me>
<usi63b$2e7ob$1@dont-email.me> <usii3u$2gn6l$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 21:04:58 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="7bba1e21ad186023a2af4b4bf0f27e98";
logging-data="2645563"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/mZY6DGwgnCZ+egLJor6gD"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:rnUvk+MSDZengJwwmo1zKEirngc=
In-Reply-To: <usii3u$2gn6l$4@dont-email.me>
Content-Language: en-US
 by: olcott - Sat, 9 Mar 2024 21:04 UTC

On 3/9/2024 2:51 PM, immibis wrote:
> On 9/03/24 18:26, olcott wrote:
>> On 3/9/2024 10:45 AM, immibis wrote:
>>> Any Turing Machine can be converted to an Olcott Machine if it just
>>> deletes the extra input at the beginning before it does whatever it
>>> does.
>>
>> Wrong you are doing the conversion backwards.
>> That is how you convert an Olcott machine into a Turing machine.
>
> Wrong I am doing the conversion the right way. You are doing it
> backwards. To convert an Olcott machine into a Turing machine you need
> to insert the code which adds the machine description to the tape.
>
>>> NO is the wrong answer for that input because that input does halt.
>>> Your halt decider accidentally aborts inputs that do terminate or it
>>> accidentally does not abort inputs that do not terminate. It is
>>> impossible for a simulating halt decider to not make at least one of
>>> these mistakes (possibly both).
>>>
>>
>> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
>> and verified facts supersede all theories to the contrary.
>
> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ actually does the opposite of
> what it must do, so it's wrong.

*Please see my new post that explains these things more clearly*
[Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usk8s1$2v4mk$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.le...@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)
Date: Sun, 10 Mar 2024 14:25:37 +0200
Organization: -
Lines: 40
Message-ID: <usk8s1$2v4mk$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org> <usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me> <usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me> <use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me> <use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me> <8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me> <usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me> <usi0ej$2d0oc$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="358b827b9e20a75857a566c986cf61e9";
logging-data="3117780"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX195v0iID8zjBBxa4gwdu0gT"
User-Agent: Unison/2.2
Cancel-Lock: sha1:yS42Zb97+6Sl365wDOEe0l6ptZs=
 by: Mikko - Sun, 10 Mar 2024 12:25 UTC

On 2024-03-09 15:49:39 +0000, olcott said:

> On 3/9/2024 3:07 AM, Mikko wrote:
>> On 2024-03-08 16:09:58 +0000, olcott said:
>>
>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>
>>>>> With all of these extra frills, aren't you working outside the premise
>>>>> of the halting problem? Like how Andre pointed out.
>>>>
>>>> Yes, he is.
>>>>
>>>>> The halting problem concerns itself with turing machines and what you
>>>>> propose is not a turing machine.
>>>>
>>>> That is true. However, we can formulate similar problems and proofs
>>>> for other classes of machines.
>>>>
>>>
>>> I am working on the computability of the halting problem
>>> (the exact same TMD / input pairs) by a slightly augmented
>>> notion of Turing machines as elaborated below:
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the
>>> end of its own tape.
>>
>> An important question to answer is whether a Turing machine can
>> simulate your machines.
>
> Olcott machines are entirely comprised of a UTM + TMD and one
> extra step that any UTM could perform, append the TMD to the end
> of its own tape.

Then a Turing machine can simulate your machine.

--
Mikko

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<uskg40$30hr1$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sun, 10 Mar 2024 09:29:20 -0500
Organization: A noiseless patient Spider
Lines: 46
Message-ID: <uskg40$30hr1$2@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 10 Mar 2024 14:29:20 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3164001"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1++sSrrzX10AiYYTMQyBSq6"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:aJ0Ru2IxH6hT46/mkMcLZIk+jaY=
In-Reply-To: <usk8s1$2v4mk$1@dont-email.me>
Content-Language: en-US
 by: olcott - Sun, 10 Mar 2024 14:29 UTC

On 3/10/2024 7:25 AM, Mikko wrote:
> On 2024-03-09 15:49:39 +0000, olcott said:
>
>> On 3/9/2024 3:07 AM, Mikko wrote:
>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>
>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>
>>>>>> With all of these extra frills, aren't you working outside the
>>>>>> premise
>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>
>>>>> Yes, he is.
>>>>>
>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>> propose is not a turing machine.
>>>>>
>>>>> That is true. However, we can formulate similar problems and proofs
>>>>> for other classes of machines.
>>>>>
>>>>
>>>> I am working on the computability of the halting problem
>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>> notion of Turing machines as elaborated below:
>>>>
>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>> extra step that any UTM could perform, append the TMD to the
>>>> end of its own tape.
>>>
>>> An important question to answer is whether a Turing machine can
>>> simulate your machines.
>>
>> Olcott machines are entirely comprised of a UTM + TMD and one
>> extra step that any UTM could perform, append the TMD to the end
>> of its own tape.
>
> Then a Turing machine can simulate your machine.
>

Yes, except the TM doing the simulating cannot be an Olcott machine.

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usksqn$33a1p$3@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.hispagatos.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: new...@immibis.com (immibis)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Sun, 10 Mar 2024 19:06:15 +0100
Organization: A noiseless patient Spider
Lines: 46
Message-ID: <usksqn$33a1p$3@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 10 Mar 2024 18:06:16 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3254329"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/kG/UVnMbqhWmzg4YuGnnQ"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:sOn6wgLY2wOW2yoJLQYjXSa6Bus=
Content-Language: en-US
In-Reply-To: <uskg40$30hr1$2@dont-email.me>
 by: immibis - Sun, 10 Mar 2024 18:06 UTC

On 10/03/24 15:29, olcott wrote:
> On 3/10/2024 7:25 AM, Mikko wrote:
>> On 2024-03-09 15:49:39 +0000, olcott said:
>>
>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>
>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>
>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>> premise
>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>
>>>>>> Yes, he is.
>>>>>>
>>>>>>> The halting problem concerns itself with turing machines and what
>>>>>>> you
>>>>>>> propose is not a turing machine.
>>>>>>
>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>> for other classes of machines.
>>>>>>
>>>>>
>>>>> I am working on the computability of the halting problem
>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>> notion of Turing machines as elaborated below:
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the
>>>>> end of its own tape.
>>>>
>>>> An important question to answer is whether a Turing machine can
>>>> simulate your machines.
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the end
>>> of its own tape.
>>
>> Then a Turing machine can simulate your machine.
>>
>
> Yes, except the TM doing the simulating cannot be an Olcott machine.
>
Why can't the TM doing the simulating have its own machine description
on its tape when it begins?

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usmk7t$3hvpu$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.le...@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)
Date: Mon, 11 Mar 2024 11:51:57 +0200
Organization: -
Lines: 53
Message-ID: <usmk7t$3hvpu$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org> <usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me> <usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me> <use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me> <use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me> <8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me> <usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me> <usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me> <uskg40$30hr1$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3735358"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18fgXOzA1tDjpnECue4Jyqs"
User-Agent: Unison/2.2
Cancel-Lock: sha1:8UPRFHLWmNT5ZJ5lmHCfPUzmIw4=
 by: Mikko - Mon, 11 Mar 2024 09:51 UTC

On 2024-03-10 14:29:20 +0000, olcott said:

> On 3/10/2024 7:25 AM, Mikko wrote:
>> On 2024-03-09 15:49:39 +0000, olcott said:
>>
>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>
>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>
>>>>>>> With all of these extra frills, aren't you working outside the premise
>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>
>>>>>> Yes, he is.
>>>>>>
>>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>>> propose is not a turing machine.
>>>>>>
>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>> for other classes of machines.
>>>>>>
>>>>>
>>>>> I am working on the computability of the halting problem
>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>> notion of Turing machines as elaborated below:
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the
>>>>> end of its own tape.
>>>>
>>>> An important question to answer is whether a Turing machine can
>>>> simulate your machines.
>>>
>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>> extra step that any UTM could perform, append the TMD to the end
>>> of its own tape.
>>
>> Then a Turing machine can simulate your machine.
>>
>
> Yes, except the TM doing the simulating cannot be an Olcott machine.

That is not "ecept", that is containted in what the word "Truring machine"
means.

Anway, a Truing machine can, with a simulation of your machine, compute
everything your machine can, so your machine cannot compute anyting a
Turing machine cannot.

--
Mikko

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usn4k9$3li08$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Mon, 11 Mar 2024 09:31:37 -0500
Organization: A noiseless patient Spider
Lines: 72
Message-ID: <usn4k9$3li08$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 14:31:37 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3852296"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1828NQfNtGvOgqTEA9RQzTk"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:MvipwKTAf2pEfgXhwjwtPn8b4Tg=
Content-Language: en-US
In-Reply-To: <usmk7t$3hvpu$1@dont-email.me>
 by: olcott - Mon, 11 Mar 2024 14:31 UTC

On 3/11/2024 4:51 AM, Mikko wrote:
> On 2024-03-10 14:29:20 +0000, olcott said:
>
>> On 3/10/2024 7:25 AM, Mikko wrote:
>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>
>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>
>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>
>>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>>> premise
>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>
>>>>>>> Yes, he is.
>>>>>>>
>>>>>>>> The halting problem concerns itself with turing machines and
>>>>>>>> what you
>>>>>>>> propose is not a turing machine.
>>>>>>>
>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>> for other classes of machines.
>>>>>>>
>>>>>>
>>>>>> I am working on the computability of the halting problem
>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>> notion of Turing machines as elaborated below:
>>>>>>
>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>> end of its own tape.
>>>>>
>>>>> An important question to answer is whether a Turing machine can
>>>>> simulate your machines.
>>>>
>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>> extra step that any UTM could perform, append the TMD to the end
>>>> of its own tape.
>>>
>>> Then a Turing machine can simulate your machine.
>>>
>>
>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>
> That is not "ecept", that is containted in what the word "Truring machine"
> means.
>
> Anway, a Truing machine can, with a simulation of your machine, compute
> everything your machine can, so your machine cannot compute anyting a
> Turing machine cannot.
>

Turing Machines, Olcott Machines, RASP machines and my C functions
can always correctly report on the behavior of their actual input
When they report on this question:
Will you halt if you never abort your simulation?

*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(a) If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usn7b3$3m7lb$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.le...@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)
Date: Mon, 11 Mar 2024 17:17:55 +0200
Organization: -
Lines: 64
Message-ID: <usn7b3$3m7lb$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org> <usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me> <usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me> <use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me> <use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me> <8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me> <usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me> <usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me> <uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me> <usn4k9$3li08$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="6b8d7ec24bb34a3a137c9d07b6c90770";
logging-data="3874475"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+ImG+zTdtddxgHUh8TznP1"
User-Agent: Unison/2.2
Cancel-Lock: sha1:hfCuP22qbc0FdCMYe1M0ZH6gaZE=
 by: Mikko - Mon, 11 Mar 2024 15:17 UTC

On 2024-03-11 14:31:37 +0000, olcott said:

> On 3/11/2024 4:51 AM, Mikko wrote:
>> On 2024-03-10 14:29:20 +0000, olcott said:
>>
>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>
>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>
>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>
>>>>>>>>> With all of these extra frills, aren't you working outside the premise
>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>
>>>>>>>> Yes, he is.
>>>>>>>>
>>>>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>>>>> propose is not a turing machine.
>>>>>>>>
>>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>>> for other classes of machines.
>>>>>>>>
>>>>>>>
>>>>>>> I am working on the computability of the halting problem
>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>
>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>> end of its own tape.
>>>>>>
>>>>>> An important question to answer is whether a Turing machine can
>>>>>> simulate your machines.
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>> of its own tape.
>>>>
>>>> Then a Turing machine can simulate your machine.
>>>>
>>>
>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>
>> That is not "ecept", that is containted in what the word "Truring machine"
>> means.
>>
>> Anway, a Truing machine can, with a simulation of your machine, compute
>> everything your machine can, so your machine cannot compute anyting a
>> Turing machine cannot.
>>
>
> Turing Machines, Olcott Machines, RASP machines and my C functions
> can always correctly report on the behavior of their actual input
> When they report on this question:
> Will you halt if you never abort your simulation?

If they only talk about themselves they are not useful.

--
Mikko

H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

<usn89c$3m7k2$4@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when report
s_on_the_actual_behavior_that_it_sees
Date: Mon, 11 Mar 2024 10:34:04 -0500
Organization: A noiseless patient Spider
Lines: 75
Message-ID: <usn89c$3m7k2$4@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me>
<usn4k9$3li08$1@dont-email.me> <usn7b3$3m7lb$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 15:34:05 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3874434"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19hV5+BHS0B4w6WGT4PmdTk"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:0hAa0xzCpSVSvvqcv25fnZQIBXI=
In-Reply-To: <usn7b3$3m7lb$1@dont-email.me>
Content-Language: en-US
 by: olcott - Mon, 11 Mar 2024 15:34 UTC

On 3/11/2024 10:17 AM, Mikko wrote:
> On 2024-03-11 14:31:37 +0000, olcott said:
>
>> On 3/11/2024 4:51 AM, Mikko wrote:
>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>
>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>
>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>
>>>>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>>>>> premise
>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>
>>>>>>>>> Yes, he is.
>>>>>>>>>
>>>>>>>>>> The halting problem concerns itself with turing machines and
>>>>>>>>>> what you
>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>
>>>>>>>>> That is true. However, we can formulate similar problems and
>>>>>>>>> proofs
>>>>>>>>> for other classes of machines.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am working on the computability of the halting problem
>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>
>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>> end of its own tape.
>>>>>>>
>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>> simulate your machines.
>>>>>>
>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>> of its own tape.
>>>>>
>>>>> Then a Turing machine can simulate your machine.
>>>>>
>>>>
>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>
>>> That is not "ecept", that is containted in what the word "Truring
>>> machine"
>>> means.
>>>
>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>> everything your machine can, so your machine cannot compute anyting a
>>> Turing machine cannot.
>>>
>>
>> Turing Machines, Olcott Machines, RASP machines and my C functions
>> can always correctly report on the behavior of their actual input
>> When they report on this question:
>> Will you halt if you never abort your simulation?
>
> If they only talk about themselves they are not useful.
>

When every simulating halt decider reports on the actual behavior
that it actually sees, then the pathological input does not
thwart it.

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usncqt$1hqqd$2@i2pn2.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!.POSTED!not-for-mail
From: rich...@damon-family.org (Richard Damon)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Mon, 11 Mar 2024 09:51:41 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usncqt$1hqqd$2@i2pn2.org>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me>
<usn4k9$3li08$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 16:51:42 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1633101"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <usn4k9$3li08$1@dont-email.me>
Content-Language: en-US
 by: Richard Damon - Mon, 11 Mar 2024 16:51 UTC

On 3/11/24 7:31 AM, olcott wrote:
> On 3/11/2024 4:51 AM, Mikko wrote:
>> On 2024-03-10 14:29:20 +0000, olcott said:
>>
>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>
>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>
>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>
>>>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>>>> premise
>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>
>>>>>>>> Yes, he is.
>>>>>>>>
>>>>>>>>> The halting problem concerns itself with turing machines and
>>>>>>>>> what you
>>>>>>>>> propose is not a turing machine.
>>>>>>>>
>>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>>> for other classes of machines.
>>>>>>>>
>>>>>>>
>>>>>>> I am working on the computability of the halting problem
>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>
>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>> end of its own tape.
>>>>>>
>>>>>> An important question to answer is whether a Turing machine can
>>>>>> simulate your machines.
>>>>>
>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>> of its own tape.
>>>>
>>>> Then a Turing machine can simulate your machine.
>>>>
>>>
>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>
>> That is not "ecept", that is containted in what the word "Truring
>> machine"
>> means.
>>
>> Anway, a Truing machine can, with a simulation of your machine, compute
>> everything your machine can, so your machine cannot compute anyting a
>> Turing machine cannot.
>>
>
> Turing Machines, Olcott Machines, RASP machines and my C functions
> can always correctly report on the behavior of their actual input
> When they report on this question:
> Will you halt if you never abort your simulation?

And to see the answer to that question for a machine that DOES abort its
simulation it mean giving that input to a DIFFERENT machine that just
doesn't abort its simulation, which means the input doesn't change, and
if it was using a copy of this machine, it doesn't change, unless the
input somehow breaks the ability of Turing Machines to actually have a
reference in to that says "The decider looking at me", which H^ doesn't.

Thus when H aborts, it needs to look as something like the simulation
that H1 does to see if it was right to abort, and it is proven wrong.

>
> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted then
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
>
>

And he is using my definition above.

IF H(<M>,d) can correctly determine that UTM(<M>,d) would not halt, then
it is correct to abort its simulation and return non-halting.

You have to use the definitions that people intended, not what you think
they are when you interpret the statements. Professor Sipser
(incorrectly) assumed you knew the conventional meaning of the words
when he wrote his reply.

This is a fundamental problem with you, you don't get to inject your
(inaccurate) meaning into the meanings of what other people say.

Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

<usnd6n$1hqqd$3@i2pn2.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!.POSTED!not-for-mail
From: rich...@damon-family.org (Richard Damon)
Newsgroups: comp.theory
Subject: Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when re
ports_on_the_actual_behavior_that_it_sees
Date: Mon, 11 Mar 2024 09:57:59 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usnd6n$1hqqd$3@i2pn2.org>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me>
<usn4k9$3li08$1@dont-email.me> <usn7b3$3m7lb$1@dont-email.me>
<usn89c$3m7k2$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 16:57:59 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1633101"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <usn89c$3m7k2$4@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
 by: Richard Damon - Mon, 11 Mar 2024 16:57 UTC

On 3/11/24 8:34 AM, olcott wrote:

> When every simulating halt decider reports on the actual behavior
> that it actually sees, then the pathological input does not
> thwart it.
>

And your world is then based on lies.

That means that the "blind" decider can just say that nothing halts
because he nevver saw it halt.

Halting, is an OBJECTIVE measure, and thus has an OBJECTIVE answer. If
some decider thinks it sees something different, it is WRONG.

You don't seem to understand that, because I don't think you actually
beleive in objective truth. You may claim to, but you don't, as it seems
you think it is ok to redefine or change things and still claim you are
working on the original, in other words, you believe in LYING.

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<usno81$3q6km$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Mon, 11 Mar 2024 15:06:24 -0500
Organization: A noiseless patient Spider
Lines: 120
Message-ID: <usno81$3q6km$1@dont-email.me>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me>
<usn4k9$3li08$1@dont-email.me> <usncqt$1hqqd$2@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 20:06:26 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="4004502"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18bO/4PeZOz+R4kIiWqslp/"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Xi37+QwlTQxE+77I8+d1Ahxops4=
Content-Language: en-US
In-Reply-To: <usncqt$1hqqd$2@i2pn2.org>
 by: olcott - Mon, 11 Mar 2024 20:06 UTC

On 3/11/2024 11:51 AM, Richard Damon wrote:
> On 3/11/24 7:31 AM, olcott wrote:
>> On 3/11/2024 4:51 AM, Mikko wrote:
>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>
>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>
>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>
>>>>>>>>>> With all of these extra frills, aren't you working outside the
>>>>>>>>>> premise
>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>
>>>>>>>>> Yes, he is.
>>>>>>>>>
>>>>>>>>>> The halting problem concerns itself with turing machines and
>>>>>>>>>> what you
>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>
>>>>>>>>> That is true. However, we can formulate similar problems and
>>>>>>>>> proofs
>>>>>>>>> for other classes of machines.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am working on the computability of the halting problem
>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>
>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>> end of its own tape.
>>>>>>>
>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>> simulate your machines.
>>>>>>
>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>> of its own tape.
>>>>>
>>>>> Then a Turing machine can simulate your machine.
>>>>>
>>>>
>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>
>>> That is not "ecept", that is containted in what the word "Truring
>>> machine"
>>> means.
>>>
>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>> everything your machine can, so your machine cannot compute anyting a
>>> Turing machine cannot.
>>>
>>
>> Turing Machines, Olcott Machines, RASP machines and my C functions
>> can always correctly report on the behavior of their actual input
>> When they report on this question:
>> Will you halt if you never abort your simulation?
>
> And to see the answer to that question for a machine that DOES abort its
> simulation it mean giving that input to a DIFFERENT machine that just
> doesn't abort its simulation, which means the input doesn't change, and
> if it was using a copy of this machine, it doesn't change, unless the
> input somehow breaks the ability of Turing Machines to actually have a
> reference in to that says "The decider looking at me", which H^ doesn't.
>
H1(D,D) and H(D,D) know their own machine address so they can tell
this input is looking at me.

> Thus when H aborts, it needs to look as something like the simulation
> that H1 does to see if it was right to abort, and it is proven wrong.
>
As soon as H1(D,D) or H(D,D) sees that D is calling themselves with
their same input and there are no conditional branch instructions
inbetween they have their abort criteria.

>>
>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>> (a) If simulating halt decider H correctly simulates its input D until
>> H correctly determines that its simulated D would never stop running
>> unless aborted then
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>>
>>
>
> And he is using my definition above.
>
I don't think so.
H1(D,D) and H(D,D) are being asked:
Will you halt if you never abort your simulation?

> IF H(<M>,d) can correctly determine that UTM(<M>,d) would not halt, then
> it is correct to abort its simulation and return non-halting.
>
> You have to use the definitions that people intended,

I am saying that when we use a different definition that cannot
be self-contradictory then my C functions H1(D,D)==1 and H(D,D)==0
(that know their own machine) address both get the correct answer
for the new definition that cannot be contradicted:
Will you halt if you never abort your simulation?

> not what you think
> they are when you interpret the statements. Professor Sipser
> (incorrectly) assumed you knew the conventional meaning of the words
> when he wrote his reply.
>
> This is a fundamental problem with you, you don't get to inject your
> (inaccurate) meaning into the meanings of what other people say.

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

Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

<uso4dr$1ipmh$1@i2pn2.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!.POSTED!not-for-mail
From: rich...@damon-family.org (Richard Damon)
Newsgroups: comp.theory
Subject: Re: We finally know exactly how H1(D,D) derives a different result
than H(D,D)
Date: Mon, 11 Mar 2024 16:34:19 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <uso4dr$1ipmh$1@i2pn2.org>
References: <usda7b$18hee$1@dont-email.me> <usdf9p$15934$2@i2pn2.org>
<usdh1e$19t14$1@dont-email.me> <usdrrd$1bil8$1@dont-email.me>
<usdseg$1bqt3$2@dont-email.me> <usdvj7$1fvhm$4@dont-email.me>
<use138$15q44$4@i2pn2.org> <use1sh$1gd96$2@dont-email.me>
<use37h$15q45$3@i2pn2.org> <use4f1$1grfn$1@dont-email.me>
<8634t1nx2p.fsf@yaxley.in> <usfase$1p1t5$1@dont-email.me>
<usfd8m$1p8cg$4@dont-email.me> <ush8rt$288t1$1@dont-email.me>
<usi0ej$2d0oc$2@dont-email.me> <usk8s1$2v4mk$1@dont-email.me>
<uskg40$30hr1$2@dont-email.me> <usmk7t$3hvpu$1@dont-email.me>
<usn4k9$3li08$1@dont-email.me> <usncqt$1hqqd$2@i2pn2.org>
<usno81$3q6km$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Mar 2024 23:34:21 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1664721"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <usno81$3q6km$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
 by: Richard Damon - Mon, 11 Mar 2024 23:34 UTC

On 3/11/24 1:06 PM, olcott wrote:
> On 3/11/2024 11:51 AM, Richard Damon wrote:
>> On 3/11/24 7:31 AM, olcott wrote:
>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>
>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>
>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>>
>>>>>>>>>>> With all of these extra frills, aren't you working outside
>>>>>>>>>>> the premise
>>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>>
>>>>>>>>>> Yes, he is.
>>>>>>>>>>
>>>>>>>>>>> The halting problem concerns itself with turing machines and
>>>>>>>>>>> what you
>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>
>>>>>>>>>> That is true. However, we can formulate similar problems and
>>>>>>>>>> proofs
>>>>>>>>>> for other classes of machines.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am working on the computability of the halting problem
>>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>
>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>>> end of its own tape.
>>>>>>>>
>>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>>> simulate your machines.
>>>>>>>
>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>>> of its own tape.
>>>>>>
>>>>>> Then a Turing machine can simulate your machine.
>>>>>>
>>>>>
>>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>>
>>>> That is not "ecept", that is containted in what the word "Truring
>>>> machine"
>>>> means.
>>>>
>>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>>> everything your machine can, so your machine cannot compute anyting a
>>>> Turing machine cannot.
>>>>
>>>
>>> Turing Machines, Olcott Machines, RASP machines and my C functions
>>> can always correctly report on the behavior of their actual input
>>> When they report on this question:
>>> Will you halt if you never abort your simulation?
>>
>> And to see the answer to that question for a machine that DOES abort
>> its simulation it mean giving that input to a DIFFERENT machine that
>> just doesn't abort its simulation, which means the input doesn't
>> change, and if it was using a copy of this machine, it doesn't change,
>> unless the input somehow breaks the ability of Turing Machines to
>> actually have a reference in to that says "The decider looking at me",
>> which H^ doesn't.
>>
> H1(D,D) and H(D,D) know their own machine address so they can tell
> this input is looking at me.

Right, but the question isn't do they call me, it is do I NEED to abort.

If they DO abort, the NEED has to be tested, but looking at a real
simulator.

Of course, this isn't something THEY can do, as if they did, they would
have already done it.

This is the test of "the quality department" that sees if the product
meets its specifications.

You are just proving your stupidity and utter lack of the understanding
of REQUIREMENTS.

>
>> Thus when H aborts, it needs to look as something like the simulation
>> that H1 does to see if it was right to abort, and it is proven wrong.
>>
> As soon as H1(D,D) or H(D,D) sees that D is calling themselves with
> their same input and there are no conditional branch instructions
> inbetween they have their abort criteria.
>

Which gives them the wrong answer. You just don't understand that.

Since they DO abort by that condition, that makes the input, which uses
that same algorithm, halting, so THIS COPY didn't need to abort, but it
did anyways since that is what was programmed.

Since the input doesn't actually "Reference" this copy of the machine,
we can imagine changing it without touching the contents of the input,
and when we do that, we see that it would stop without the abort, thus
they didn't NEED to abort, but did.

You just are ignorant of the rules of REQUIREMENTS.

>>>
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (a) If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never stop
>>> running unless aborted then
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>>
>>>
>>
>> And he is using my definition above.
>>
> I don't think so.
> H1(D,D) and H(D,D) are being asked:
> Will you halt if you never abort your simulation?

Right, but they are what the are, so that is the hypothetical "If I
changed this copy" not "If I changed all copies of me", as that is the
meaning in Computation Theory, since the input doesn't REFERENCE the
decider, but just has a copy. We can change this machine for
hypotheticals without changing the input.

>
>> IF H(<M>,d) can correctly determine that UTM(<M>,d) would not halt,
>> then it is correct to abort its simulation and return non-halting.
>>
>> You have to use the definitions that people intended,
>
> I am saying that when we use a different definition that cannot
> be self-contradictory then my C functions H1(D,D)==1 and H(D,D)==0
> (that know their own machine) address both get the correct answer
> for the new definition that cannot be contradicted:
> Will you halt if you never abort your simulation?

In other words, you admit you are lying about doing the Halting Problem.

Your version defies determinism and looks at things that are not, in
otherwords, is a LIE.

Note, the ACTUAL problem doesn't HAVE the SELF-contradictory nature, the
input is only a SPECIFIC desider contradictory, which isn't "itself"

Your changing the input from a specific instance of H^ built on a
specific instance of H is an invalid transformation.

>
>> not what you think they are when you interpret the statements.
>> Professor Sipser (incorrectly) assumed you knew the conventional
>> meaning of the words when he wrote his reply.
>>
>> This is a fundamental problem with you, you don't get to inject your
>> (inaccurate) meaning into the meanings of what other people say.
>


devel / comp.theory / Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

Pages:1234567891011121314
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor