Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Your program is sick! Shoot it and put it out of its memory.


devel / comp.theory / Re: Concise refutation of halting problem proofs V43 [where people get stuck]

SubjectAuthor
* Concise refutation of halting problem proofs V43 [where people getolcott
+* Concise refutation of halting problem proofs V43 [where peopleSteve Parker
|`* Concise refutation of halting problem proofs V43 [where peopleolcott
| `* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|  `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   +* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |`* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   | `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |  `* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   |   `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |    `* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   |     `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |      `* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   |       `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |        `* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   |         `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |          `* Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   |           `* Concise refutation of halting problem proofs V43 [where peopleolcott
|   |            `- Concise refutation of halting problem proofs V43 [where peopleRichard Damon
|   `- Concise refutation of halting problem proofs V43 [where peopleRichard Damon
`- Concise refutation of halting problem proofs V43 [where peopleRichard Damon

1
Concise refutation of halting problem proofs V43 [where people get stuck]

<AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 10:27:27 -0600
Date: Fri, 31 Dec 2021 10:27:26 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V43 [where people get
stuck]
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
Lines: 44
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tMyIYaKBPLBAzi78tnLsicLaODsDIqPUHMYLkqRvsRnw+cO+1/ufqGL2lRLwv5KTqT5aRu8RDM1KVfI!Zf1lrkvND+oT2wBP1SBreG5USzQjb9oN34Edg9ZfF2gEoDokjoIYlbjscozKWngYRtWUikVNCqi1!Ng==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2943
 by: olcott - Fri, 31 Dec 2021 16:27 UTC

Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.

*My criterion measure with Ben's notational conventions*
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

We know that H would correctly decide the halt status of its input on
the basis of correctly deciding the halt status of the UTM simulation of
its input.

We know this because a UTM simulation of the Turing machine description
is computationally equivalent to the direct execution of this same
Turing machine.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) at Ĥ.qx halts.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) at Ĥ.qx does not halt.

THIS IS WHERE PEOPLE GET STUCK
THIS IS WHERE PEOPLE GET STUCK
THIS IS WHERE PEOPLE GET STUCK

The criterion measure of H applies recursively such that the UTM would
simulate itself.

The following is the UTM simulation of a single input pair:
(a) copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩
(b) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ with the UTM

We know that this means that when embedded_H computes the mapping from
its input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the behavior of the
UTM simulation of this input that its transition to Ĥ.qn is correct.

https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (315-320)

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<sqnb4c$1nl5$1@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: joh...@hotmail.com (Steve Parker)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Date: Fri, 31 Dec 2021 08:28:58 -0800
Organization: Aioe.org NNTP Server
Message-ID: <sqnb4c$1nl5$1@gioia.aioe.org>
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
Reply-To: johndo@hotmail.com
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="56997"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Steve Parker - Fri, 31 Dec 2021 16:28 UTC

On 12/31/2021 8:27 AM, olcott wrote:
> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.

Shut up idiot.

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 10:31:57 -0600
Date: Fri, 31 Dec 2021 10:31:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqnb4c$1nl5$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
Lines: 16
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PbgHq72G6v3nMv/xkNVODi2iughFek5vJQ1my8rLqJiQSGRXjQ/etUIJX1E2Uq0Sn8hUobGT/8CujiA!e8UsZDuin60tfDv7nSRRloF+NUlMtVqIWQU1mT05Z1peskTJzStwi1d5t3F7ZR8ZairBUuzwWpzK!NQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 1751
 by: olcott - Fri, 31 Dec 2021 16:31 UTC

On 12/31/2021 10:28 AM, Steve Parker wrote:
> On 12/31/2021 8:27 AM, olcott wrote:
>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>
> Shut up idiot.
>

If you can't point to any mistakes that proves that you are the idiot

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<MgGzJ.130767$SR4.33717@fx43.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 63
Message-ID: <MgGzJ.130767$SR4.33717@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 11:32:46 -0500
X-Received-Bytes: 3279
 by: Richard Damon - Fri, 31 Dec 2021 16:32 UTC

On 12/31/21 11:27 AM, olcott wrote:
> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>
> *My criterion measure with Ben's notational conventions*
> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>
> We know that H would correctly decide the halt status of its input on
> the basis of correctly deciding the halt status of the UTM simulation of
> its input.
>
> We know this because a UTM simulation of the Turing machine description
> is computationally equivalent to the direct execution of this same
> Turing machine.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) at Ĥ.qx halts.
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) at Ĥ.qx does not halt.
>
> THIS IS WHERE PEOPLE GET STUCK
> THIS IS WHERE PEOPLE GET STUCK
> THIS IS WHERE PEOPLE GET STUCK
>
> The criterion measure of H applies recursively such that the UTM would
> simulate itself.

No it doesn't, unless H itself is just a UTM.

The UTM simulates the input AS SPECIFIED, which doesn't have a UTM, but
an H, and the UTM looks at what H says it will do, and we can see if H
was right.

>
> The following is the UTM simulation of a single input pair:
> (a) copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩
> (b) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ with the UTM

Only if H is just a UM. IS IT?

The UTM should simualate H applied to <H^> <H^>.

If THAT actually is a UTM, then you just proved that H doesn't answer
ans do fails.

>
> We know that this means that when embedded_H computes the mapping from
> its input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the behavior of the
> UTM simulation of this input that its transition to Ĥ.qn is correct.
>

Nope FAIL.

You just prove that you are an idiot, and don't understand anything
about specifiecations.

No wonder you couldn't keep yourself employed as a programmer.

> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (315-320)
>

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<wHGzJ.52272$bo.39043@fx18.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 21
Message-ID: <wHGzJ.52272$bo.39043@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 12:01:18 -0500
X-Received-Bytes: 1838
 by: Richard Damon - Fri, 31 Dec 2021 17:01 UTC

On 12/31/21 11:31 AM, olcott wrote:
> On 12/31/2021 10:28 AM, Steve Parker wrote:
>> On 12/31/2021 8:27 AM, olcott wrote:
>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>>
>> Shut up idiot.
>>
>
> If you can't point to any mistakes that proves that you are the idiot
>

How about that it can be simple shown by inspection that if H and
embedded_H applied to <H^> <H^> goes to H.qn, then so does H^ applied to
<H^> go to H^.qn and Halts, thus H was WRONG.

You have yet to point out an actual mistake in that simple logic, just
give rambling excuses why that shouldn't count, when it is the actual
DEFINITION of what is the requirement.

FAIL.

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 11:19:42 -0600
Date: Fri, 31 Dec 2021 11:19:41 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <wHGzJ.52272$bo.39043@fx18.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
Lines: 44
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9i6WLllzWoqv6DMxHnJCepvkDZR+JjAhsIOkZe9cTOD+ROii3xa7H2mojpRVKQQ4pDfFccRfGPQ0CRC!CG1L41SdAOgwpn44V2lr0ml4fzdOOOBy/QryiJ6StRq8S/mJ/9dz0jNwfwb9wTEQrzelY48uxm0r!KA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2923
 by: olcott - Fri, 31 Dec 2021 17:19 UTC

On 12/31/2021 11:01 AM, Richard Damon wrote:
> On 12/31/21 11:31 AM, olcott wrote:
>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>> Ĥ.qn on the basis of the behavior of the UTM simulation of these
>>>> inputs.
>>>
>>> Shut up idiot.
>>>
>>
>> If you can't point to any mistakes that proves that you are the idiot
>>
>
> How about that it can be simple shown by inspection that if H and
> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^ applied to
> <H^> go to H^.qn and Halts, thus H was WRONG.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
(no embedded_H ever aborts the simulation of its input).

All behavior of Ĥ applied to ⟨Ĥ⟩ that is not an actual input to
embedded_H is totally irrelevant to determining whether or not the
embedded_H transition to Ĥ.qn is correct. Actual computer scientists
will know this.

> You have yet to point out an actual mistake in that simple logic, just
> give rambling excuses why that shouldn't count, when it is the actual
> DEFINITION of what is the requirement.
>
> FAIL.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 11:57:55 -0600
Date: Fri, 31 Dec 2021 11:57:55 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
Lines: 52
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Zv0aigET+28rCBH/EQ/C1ro1BUZY7jApZC8kckpFAsp1BSK1BtLZS8ybr9vMLO6DMDC/msf2it3ofwz!lxYam/ibEMK0qcN81tMgTIGV7pSzmpdPHaiHLY1xK4uQMuuILTW1hcq+Bxt+vuKRUwCBvyenqqkR!Sg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3242
 by: olcott - Fri, 31 Dec 2021 17:57 UTC

On 12/31/2021 11:19 AM, olcott wrote:
> On 12/31/2021 11:01 AM, Richard Damon wrote:
>> On 12/31/21 11:31 AM, olcott wrote:
>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> to Ĥ.qn on the basis of the behavior of the UTM simulation of these
>>>>> inputs.
>>>>
>>>> Shut up idiot.
>>>>
>>>
>>> If you can't point to any mistakes that proves that you are the idiot
>>>
>>
>> How about that it can be simple shown by inspection that if H and
>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^ applied
>> to <H^> go to H^.qn and Halts, thus H was WRONG.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
> Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
> (no embedded_H ever aborts the simulation of its input).

No embedded_H ever aborts the simulation of its input until:
(a) Its input halts on its own.
(b) It detects that its input would never halt on its own.

>
> All behavior of Ĥ applied to ⟨Ĥ⟩ that is not an actual input to
> embedded_H is totally irrelevant to determining whether or not the
> embedded_H transition to Ĥ.qn is correct. Actual computer scientists
> will know this.
>
>> You have yet to point out an actual mistake in that simple logic, just
>> give rambling excuses why that shouldn't count, when it is the actual
>> DEFINITION of what is the requirement.
>>
>> FAIL.
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<ZiIzJ.69799$xe2.63697@fx16.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 64
Message-ID: <ZiIzJ.69799$xe2.63697@fx16.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 13:51:39 -0500
X-Received-Bytes: 3390
 by: Richard Damon - Fri, 31 Dec 2021 18:51 UTC

On 12/31/21 12:19 PM, olcott wrote:
> On 12/31/2021 11:01 AM, Richard Damon wrote:
>> On 12/31/21 11:31 AM, olcott wrote:
>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> to Ĥ.qn on the basis of the behavior of the UTM simulation of these
>>>>> inputs.
>>>>
>>>> Shut up idiot.
>>>>
>>>
>>> If you can't point to any mistakes that proves that you are the idiot
>>>
>>
>> How about that it can be simple shown by inspection that if H and
>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^ applied
>> to <H^> go to H^.qn and Halts, thus H was WRONG.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
> Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
> (no embedded_H ever aborts the simulation of its input).

Then NO H can either, as it is a copy of H and must behave the same, and
thus H never gives an answer to H(<H^>.<H^>)

You have just admitted to FAILURE.

>
> All behavior of Ĥ applied to ⟨Ĥ⟩ that is not an actual input to
> embedded_H is totally irrelevant to determining whether or not the
> embedded_H transition to Ĥ.qn is correct. Actual computer scientists
> will know this.
>

But all H^ applied to <H^> behave the same. DEFINITION.

Anyone who know anything about computations knows this (which seems to
exclude you).

Do you want to try to show some actual Turing Machine M when given a
specific input w can act differently on two occurrences?

GO ahead, show one, doesn't even need to be your precious top secret H,
that does this magical operation.

This is what you just claimed was possible, that two copies of the
Turing Machine H^, when given identical inputs <H^>, could behave
differently.

UTTER FAILURE.

>> You have yet to point out an actual mistake in that simple logic, just
>> give rambling excuses why that shouldn't count, when it is the actual
>> DEFINITION of what is the requirement.
>>
>> FAIL.
>
>

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<bkIzJ.69800$xe2.62705@fx16.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 58
Message-ID: <bkIzJ.69800$xe2.62705@fx16.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 13:52:57 -0500
X-Received-Bytes: 3213
 by: Richard Damon - Fri, 31 Dec 2021 18:52 UTC

On 12/31/21 12:57 PM, olcott wrote:
> On 12/31/2021 11:19 AM, olcott wrote:
>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>> On 12/31/21 11:31 AM, olcott wrote:
>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> to Ĥ.qn on the basis of the behavior of the UTM simulation of
>>>>>> these inputs.
>>>>>
>>>>> Shut up idiot.
>>>>>
>>>>
>>>> If you can't point to any mistakes that proves that you are the idiot
>>>>
>>>
>>> How about that it can be simple shown by inspection that if H and
>>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^ applied
>>> to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩ ⟨Ĥ⟩
>> to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
>> (no embedded_H ever aborts the simulation of its input).
>
> No embedded_H ever aborts the simulation of its input until:
> (a) Its input halts on its own.
> (b) It detects that its input would never halt on its own.
>

Proven impossible for such an algorithm to decide H^ is non-halting:

Mesage ID <FOnzJ.162569$np6.119786@fx46.iad>
Date: 2021-12-30 19:31:49 GMT
Subject: Re: Concise refutation of halting problem proofs V42 [compute
the mapping]

FAIL.

>>
>> All behavior of Ĥ applied to ⟨Ĥ⟩ that is not an actual input to
>> embedded_H is totally irrelevant to determining whether or not the
>> embedded_H transition to Ĥ.qn is correct. Actual computer scientists
>> will know this.
>>
>>> You have yet to point out an actual mistake in that simple logic,
>>> just give rambling excuses why that shouldn't count, when it is the
>>> actual DEFINITION of what is the requirement.
>>>
>>> FAIL.
>>
>>
>
>

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 13:09:05 -0600
Date: Fri, 31 Dec 2021 13:09:04 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <bkIzJ.69800$xe2.62705@fx16.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
Lines: 75
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-626+L/xVyke6xEDCM3/XorCSayTq54Qgw5ojU89SjFUg79RMqqfE05cBVM/WUlNaN3i4m5DFyg67fsi!xYx/edN9LyphGvLO30NjymJiOn2Pmie6otJaP0zkljTpEojwvtFIDYM1FaJPRBd8Ex9pSYYdH2ab!+g==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4017
 by: olcott - Fri, 31 Dec 2021 19:09 UTC

On 12/31/2021 12:52 PM, Richard Damon wrote:
> On 12/31/21 12:57 PM, olcott wrote:
>> On 12/31/2021 11:19 AM, olcott wrote:
>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> to Ĥ.qn on the basis of the behavior of the UTM simulation of
>>>>>>> these inputs.
>>>>>>
>>>>>> Shut up idiot.
>>>>>>
>>>>>
>>>>> If you can't point to any mistakes that proves that you are the idiot
>>>>>
>>>>
>>>> How about that it can be simple shown by inspection that if H and
>>>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^
>>>> applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>> to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
>>> (no embedded_H ever aborts the simulation of its input).
>>
>> No embedded_H ever aborts the simulation of its input until:
>> (a) Its input halts on its own.
>> (b) It detects that its input would never halt on its own.
>>
>
> Proven impossible for such an algorithm to decide H^ is non-halting:

If is self-evidently true that unless simulating halt decider embedded_H
aborts the simulation of its input at some point that Ĥ applied to ⟨Ĥ⟩
never stops running.

That you have never agreed to this proves that you are dishonest.

>
> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
> Date: 2021-12-30 19:31:49 GMT
> Subject: Re: Concise refutation of halting problem proofs V42 [compute
> the mapping]
>
> FAIL.
>
>>>
>>> All behavior of Ĥ applied to ⟨Ĥ⟩ that is not an actual input to
>>> embedded_H is totally irrelevant to determining whether or not the
>>> embedded_H transition to Ĥ.qn is correct. Actual computer scientists
>>> will know this.
>>>
>>>> You have yet to point out an actual mistake in that simple logic,
>>>> just give rambling excuses why that shouldn't count, when it is the
>>>> actual DEFINITION of what is the requirement.
>>>>
>>>> FAIL.
>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<2PIzJ.95859$Gco3.18861@fx01.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 105
Message-ID: <2PIzJ.95859$Gco3.18861@fx01.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 14:25:51 -0500
X-Received-Bytes: 5251
 by: Richard Damon - Fri, 31 Dec 2021 19:25 UTC

On 12/31/21 2:09 PM, olcott wrote:
> On 12/31/2021 12:52 PM, Richard Damon wrote:
>> On 12/31/21 12:57 PM, olcott wrote:
>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩
>>>>>>>> ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM simulation
>>>>>>>> of these inputs.
>>>>>>>
>>>>>>> Shut up idiot.
>>>>>>>
>>>>>>
>>>>>> If you can't point to any mistakes that proves that you are the idiot
>>>>>>
>>>>>
>>>>> How about that it can be simple shown by inspection that if H and
>>>>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^
>>>>> applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
>>>> (no embedded_H ever aborts the simulation of its input).
>>>
>>> No embedded_H ever aborts the simulation of its input until:
>>> (a) Its input halts on its own.
>>> (b) It detects that its input would never halt on its own.
>>>
>>
>> Proven impossible for such an algorithm to decide H^ is non-halting:
>
> If is self-evidently true that unless simulating halt decider embedded_H
> aborts the simulation of its input at some point that Ĥ applied to ⟨Ĥ⟩
> never stops running.
>
> That you have never agreed to this proves that you are dishonest.
>

And YOU don't understand that no ALGORITHM can detect this.

Thus, YES, if your H that doesn't abort its simulation until IT can
correctly prove the computation is non-halting, H^ will be Non-Halting
and that would be the correct answer, but H can not compute that answer,
and will be non-halting itself.

If H aborts its simulation, then it will be wrong, what ever answer it
gives.

You just don't understand the actual meaning of the problem.

No Deterministic Turing Machine can correctly decide for ALL inputs the
halting state of the described computation.

THAT is the Halting Problem.

And if no Turing Machine can do it, neither can any other deterministic
model of computation do it either, by Church-Turing.

Note, that just because any H you try to design will get the wrong
answer, or fail to answer for the H^ built on it, doesn't mean that we
can't make some OTHER decider, and have it look at H^ and figure out
that this machine is actually decidable. Linz makes no such claim about
that for this H^. Just that the one machine it was built on can't decide
this particular machine.

One it is established that for ANY prospective Halt Decider, we can come
up with a machine it can not correctly decide, you can do further logic
to show that there exist some problems that we can not PROVE that we
know their halting state. That is NOT this part of Linz's proof, but
this is a key step in that direction.

>
>>
>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>> Date: 2021-12-30 19:31:49 GMT
>> Subject: Re: Concise refutation of halting problem proofs V42 [compute
>> the mapping]
>>
>> FAIL.
>>
>>>>
>>>> All behavior of Ĥ applied to ⟨Ĥ⟩ that is not an actual input to
>>>> embedded_H is totally irrelevant to determining whether or not the
>>>> embedded_H transition to Ĥ.qn is correct. Actual computer scientists
>>>> will know this.
>>>>
>>>>> You have yet to point out an actual mistake in that simple logic,
>>>>> just give rambling excuses why that shouldn't count, when it is the
>>>>> actual DEFINITION of what is the requirement.
>>>>>
>>>>> FAIL.
>>>>
>>>>
>>>
>>>
>>
>
>

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 13:46:36 -0600
Date: Fri, 31 Dec 2021 13:46:35 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <2PIzJ.95859$Gco3.18861@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
Lines: 66
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-BbWqYLvx4t/W8v4xxSbF2GQ3I8x2gGrfdIkqQ/1lfns8suRrqmhK3DMHyOPZrOSKcCxvrNXTzwDConI!jT5VwoIaWiyzKQED1vJksw0XeXeDITlB11YR0gCm71XKVJxqBEKLfVGzOjhaeDAfk1UvvfbhKbnS!QQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4168
 by: olcott - Fri, 31 Dec 2021 19:46 UTC

On 12/31/2021 1:25 PM, Richard Damon wrote:
> On 12/31/21 2:09 PM, olcott wrote:
>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>> On 12/31/21 12:57 PM, olcott wrote:
>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩
>>>>>>>>> ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM simulation
>>>>>>>>> of these inputs.
>>>>>>>>
>>>>>>>> Shut up idiot.
>>>>>>>>
>>>>>>>
>>>>>>> If you can't point to any mistakes that proves that you are the
>>>>>>> idiot
>>>>>>>
>>>>>>
>>>>>> How about that it can be simple shown by inspection that if H and
>>>>>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^
>>>>>> applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩
>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>
>>>> No embedded_H ever aborts the simulation of its input until:
>>>> (a) Its input halts on its own.
>>>> (b) It detects that its input would never halt on its own.
>>>>
>>>
>>> Proven impossible for such an algorithm to decide H^ is non-halting:
>>
>> If is self-evidently true that unless simulating halt decider
>> embedded_H aborts the simulation of its input at some point that Ĥ
>> applied to ⟨Ĥ⟩ never stops running.
>>
>> That you have never agreed to this proves that you are dishonest.
>>
>
> And YOU don't understand that no ALGORITHM can detect this.
>
> Thus, YES, if your H that doesn't abort its simulation until IT can
> correctly prove the computation is non-halting, H^ will be Non-Halting
> and that would be the correct answer, but H can not compute that answer,
> and will be non-halting itself.
Well that is a breakthrough.

The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn even
if embedded_H cannot compute this correct halt status.

Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<weJzJ.52153$bn2.36806@fx12.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 79
Message-ID: <weJzJ.52153$bn2.36806@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 14:55:09 -0500
X-Received-Bytes: 4615
 by: Richard Damon - Fri, 31 Dec 2021 19:55 UTC

On 12/31/21 2:46 PM, olcott wrote:
> On 12/31/2021 1:25 PM, Richard Damon wrote:
>> On 12/31/21 2:09 PM, olcott wrote:
>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM simulation
>>>>>>>>>> of these inputs.
>>>>>>>>>
>>>>>>>>> Shut up idiot.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you can't point to any mistakes that proves that you are the
>>>>>>>> idiot
>>>>>>>>
>>>>>>>
>>>>>>> How about that it can be simple shown by inspection that if H and
>>>>>>> embedded_H applied to <H^> <H^> goes to H.qn, then so does H^
>>>>>>> applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩
>>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this input
>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>
>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>> (a) Its input halts on its own.
>>>>> (b) It detects that its input would never halt on its own.
>>>>>
>>>>
>>>> Proven impossible for such an algorithm to decide H^ is non-halting:
>>>
>>> If is self-evidently true that unless simulating halt decider
>>> embedded_H aborts the simulation of its input at some point that Ĥ
>>> applied to ⟨Ĥ⟩ never stops running.
>>>
>>> That you have never agreed to this proves that you are dishonest.
>>>
>>
>> And YOU don't understand that no ALGORITHM can detect this.
>>
>> Thus, YES, if your H that doesn't abort its simulation until IT can
>> correctly prove the computation is non-halting, H^ will be Non-Halting
>> and that would be the correct answer, but H can not compute that
>> answer, and will be non-halting itself.
> Well that is a breakthrough.
>
> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn even
> if embedded_H cannot compute this correct halt status.
>
> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>
>

Right, the correct answer is Non-Halting but NEITHER H or embedded_H can
give it, because if they do, it becomes the wrong answer.

Non-Halting is the correct answer ONLY BECAUSE H (and embedded_H) do not
give that answer.

H^ is allowed to work this way, since it is allowed to have a copy of H
inside it, to let it know how H will behave.

Remember ALL copies of a given algorithm will perform the exact same
computation and give the exact same answer if given the same input.

So, embedded_H not giving an answer to being applied to <H^>,<H^> means
H can not give an answer either, or that says that you didn't build your
H^ to the specifications.

So you still FAIL.

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 14:08:34 -0600
Date: Fri, 31 Dec 2021 14:08:33 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <weJzJ.52153$bn2.36806@fx12.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
Lines: 82
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-M1hDNdv6ylRsvMKTSpyhR/x81qRvbJzbtfu1wZ8uDY8BNUXYryqF6rdXmxL7+I4TjLrZH1cwuEb1Qom!ul3IEb1DfyT5XwR7+14bsno3d8VlKPMCh2xnh8MaCIxmN2MqfTPrcnjE9aYI0MbImmXVlen28NKa!0A==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4950
 by: olcott - Fri, 31 Dec 2021 20:08 UTC

On 12/31/2021 1:55 PM, Richard Damon wrote:
> On 12/31/21 2:46 PM, olcott wrote:
>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>> On 12/31/21 2:09 PM, olcott wrote:
>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM
>>>>>>>>>>> simulation of these inputs.
>>>>>>>>>>
>>>>>>>>>> Shut up idiot.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you can't point to any mistakes that proves that you are the
>>>>>>>>> idiot
>>>>>>>>>
>>>>>>>>
>>>>>>>> How about that it can be simple shown by inspection that if H
>>>>>>>> and embedded_H applied to <H^> <H^> goes to H.qn, then so does
>>>>>>>> H^ applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩
>>>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this
>>>>>>> input
>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>
>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>> (a) Its input halts on its own.
>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>
>>>>>
>>>>> Proven impossible for such an algorithm to decide H^ is non-halting:
>>>>
>>>> If is self-evidently true that unless simulating halt decider
>>>> embedded_H aborts the simulation of its input at some point that Ĥ
>>>> applied to ⟨Ĥ⟩ never stops running.
>>>>
>>>> That you have never agreed to this proves that you are dishonest.
>>>>
>>>
>>> And YOU don't understand that no ALGORITHM can detect this.
>>>
>>> Thus, YES, if your H that doesn't abort its simulation until IT can
>>> correctly prove the computation is non-halting, H^ will be
>>> Non-Halting and that would be the correct answer, but H can not
>>> compute that answer, and will be non-halting itself.
>> Well that is a breakthrough.
>>
>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn even
>> if embedded_H cannot compute this correct halt status.
>>
>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>>
>>
>
> Right, the correct answer is Non-Halting but NEITHER H or embedded_H can
> give it, because if they do, it becomes the wrong answer.
>

When embedded_H is basing its halt status decision on the behavior pure
simulation of its input then because the pure simulation of its input
would never stop running when embedded_H transitions to Ĥ.qn it is
necessarily correct because it is still true that the pure simulation of
its input would never stop running.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<83KzJ.212093$1d1.209379@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 109
Message-ID: <83KzJ.212093$1d1.209379@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 15:51:18 -0500
X-Received-Bytes: 6292
 by: Richard Damon - Fri, 31 Dec 2021 20:51 UTC

On 12/31/21 3:08 PM, olcott wrote:
> On 12/31/2021 1:55 PM, Richard Damon wrote:
>> On 12/31/21 2:46 PM, olcott wrote:
>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM
>>>>>>>>>>>> simulation of these inputs.
>>>>>>>>>>>
>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If you can't point to any mistakes that proves that you are
>>>>>>>>>> the idiot
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> How about that it can be simple shown by inspection that if H
>>>>>>>>> and embedded_H applied to <H^> <H^> goes to H.qn, then so does
>>>>>>>>> H^ applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input ⟨Ĥ⟩
>>>>>>>> ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of this
>>>>>>>> input
>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>
>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>> (a) Its input halts on its own.
>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>
>>>>>>
>>>>>> Proven impossible for such an algorithm to decide H^ is non-halting:
>>>>>
>>>>> If is self-evidently true that unless simulating halt decider
>>>>> embedded_H aborts the simulation of its input at some point that Ĥ
>>>>> applied to ⟨Ĥ⟩ never stops running.
>>>>>
>>>>> That you have never agreed to this proves that you are dishonest.
>>>>>
>>>>
>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>
>>>> Thus, YES, if your H that doesn't abort its simulation until IT can
>>>> correctly prove the computation is non-halting, H^ will be
>>>> Non-Halting and that would be the correct answer, but H can not
>>>> compute that answer, and will be non-halting itself.
>>> Well that is a breakthrough.
>>>
>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn
>>> even if embedded_H cannot compute this correct halt status.
>>>
>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>>>
>>>
>>
>> Right, the correct answer is Non-Halting but NEITHER H or embedded_H
>> can give it, because if they do, it becomes the wrong answer.
>>
>
> When embedded_H is basing its halt status decision on the behavior pure
> simulation of its input then because the pure simulation of its input
> would never stop running when embedded_H transitions to Ĥ.qn it is
> necessarily correct because it is still true that the pure simulation of
> its input would never stop running.
>

So if H IS a pure simulator, the correct answer is Non-Halting, but a
pure simulator will never abort itself to give that. H FAILS.

If H aborts its simulation, then the presumption that it was a pure
simulator doesn't hold, and it doesn't matter that what happens if
embbeded_H was a pure simulator, since it isn't.

The correct answer is the shown by the pure simulation of the input, as
the actual input.

If H aborts its simulation and returns non-halting, then the pure
simulation of its input SEES the H inside it doing the same and cause H^
to Halt, so H was WRONG, because H aborted after assuming it would never
abort. False premises do not lead to sound deductions.

Remeber the definition of Halting ISN'T changing all occuraces of the
decider to be a UTM and see what happens, it is just giving the input,
exactly as given, to a UTM and seeing what it does.

This does NOT mean you change anything else, as they aren't 'defined' to
give the right answer (that isn't an algortithm) but to give what they
give. The UTM seems H^ calling H *AS DEFINED* (not some embedded_H that
differs in algorithm) and if H aborts, it will see that.

This means that the only way H can not be incorrect is to fail to answer
as we have shown that both answers, when given to H^ are incorrect.

You are trying to pull a fast one by making H and embedded_H while on
one hand claimed to be the same, on the other to have a difference, but
if that is true, then you don't have the H^ that Linz required and are
thus caught in your lie.

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 14:59:03 -0600
Date: Fri, 31 Dec 2021 14:59:02 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
<83KzJ.212093$1d1.209379@fx99.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <83KzJ.212093$1d1.209379@fx99.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
Lines: 98
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-S8siVoCcDs+3xA/8qobZKVrRCNoSc+epzqbIkYAkDdz17tpb8um8a07w6dHp1K30+PpgcfqOA+Lar08!43HLvoMtXeSaDbWRVefMGgYXMDsMei4Qknm0gYf5s7pQmc72HVu6Y3BOYzA2pRYqM1GEszOwQVVk!rA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5780
 by: olcott - Fri, 31 Dec 2021 20:59 UTC

On 12/31/2021 2:51 PM, Richard Damon wrote:
> On 12/31/21 3:08 PM, olcott wrote:
>> On 12/31/2021 1:55 PM, Richard Damon wrote:
>>> On 12/31/21 2:46 PM, olcott wrote:
>>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM
>>>>>>>>>>>>> simulation of these inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If you can't point to any mistakes that proves that you are
>>>>>>>>>>> the idiot
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> How about that it can be simple shown by inspection that if H
>>>>>>>>>> and embedded_H applied to <H^> <H^> goes to H.qn, then so does
>>>>>>>>>> H^ applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input
>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of
>>>>>>>>> this input
>>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>>
>>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>>> (a) Its input halts on its own.
>>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>>
>>>>>>>
>>>>>>> Proven impossible for such an algorithm to decide H^ is non-halting:
>>>>>>
>>>>>> If is self-evidently true that unless simulating halt decider
>>>>>> embedded_H aborts the simulation of its input at some point that Ĥ
>>>>>> applied to ⟨Ĥ⟩ never stops running.
>>>>>>
>>>>>> That you have never agreed to this proves that you are dishonest.
>>>>>>
>>>>>
>>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>>
>>>>> Thus, YES, if your H that doesn't abort its simulation until IT can
>>>>> correctly prove the computation is non-halting, H^ will be
>>>>> Non-Halting and that would be the correct answer, but H can not
>>>>> compute that answer, and will be non-halting itself.
>>>> Well that is a breakthrough.
>>>>
>>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn
>>>> even if embedded_H cannot compute this correct halt status.
>>>>
>>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>>>>
>>>>
>>>
>>> Right, the correct answer is Non-Halting but NEITHER H or embedded_H
>>> can give it, because if they do, it becomes the wrong answer.
>>>
>>
>> When embedded_H is basing its halt status decision on the behavior
>> pure simulation of its input then because the pure simulation of its
>> input would never stop running when embedded_H transitions to Ĥ.qn it
>> is necessarily correct because it is still true that the pure
>> simulation of its input would never stop running.
>>
>
> So if H IS a pure simulator, the correct answer is Non-Halting, but a
> pure simulator will never abort itself to give that. H FAILS.
>

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

The fact that the input to embedded_H never reaches its final state
whether or not its simulation is ever aborted conclusively proves that
this input never halts therefore when embedded_H transitions to Ĥ.qn it
is necessarily correct.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<MDKzJ.251382$IW4.243734@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
<83KzJ.212093$1d1.209379@fx99.iad>
<BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 119
Message-ID: <MDKzJ.251382$IW4.243734@fx48.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 16:30:23 -0500
X-Received-Bytes: 6863
 by: Richard Damon - Fri, 31 Dec 2021 21:30 UTC

On 12/31/21 3:59 PM, olcott wrote:
> On 12/31/2021 2:51 PM, Richard Damon wrote:
>> On 12/31/21 3:08 PM, olcott wrote:
>>> On 12/31/2021 1:55 PM, Richard Damon wrote:
>>>> On 12/31/21 2:46 PM, olcott wrote:
>>>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM
>>>>>>>>>>>>>> simulation of these inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If you can't point to any mistakes that proves that you are
>>>>>>>>>>>> the idiot
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> How about that it can be simple shown by inspection that if H
>>>>>>>>>>> and embedded_H applied to <H^> <H^> goes to H.qn, then so
>>>>>>>>>>> does H^ applied to <H^> go to H^.qn and Halts, thus H was WRONG.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input
>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation of
>>>>>>>>>> this input
>>>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>>>
>>>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>>>> (a) Its input halts on its own.
>>>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Proven impossible for such an algorithm to decide H^ is
>>>>>>>> non-halting:
>>>>>>>
>>>>>>> If is self-evidently true that unless simulating halt decider
>>>>>>> embedded_H aborts the simulation of its input at some point that
>>>>>>> Ĥ applied to ⟨Ĥ⟩ never stops running.
>>>>>>>
>>>>>>> That you have never agreed to this proves that you are dishonest.
>>>>>>>
>>>>>>
>>>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>>>
>>>>>> Thus, YES, if your H that doesn't abort its simulation until IT
>>>>>> can correctly prove the computation is non-halting, H^ will be
>>>>>> Non-Halting and that would be the correct answer, but H can not
>>>>>> compute that answer, and will be non-halting itself.
>>>>> Well that is a breakthrough.
>>>>>
>>>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn
>>>>> even if embedded_H cannot compute this correct halt status.
>>>>>
>>>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>>>>>
>>>>>
>>>>
>>>> Right, the correct answer is Non-Halting but NEITHER H or embedded_H
>>>> can give it, because if they do, it becomes the wrong answer.
>>>>
>>>
>>> When embedded_H is basing its halt status decision on the behavior
>>> pure simulation of its input then because the pure simulation of its
>>> input would never stop running when embedded_H transitions to Ĥ.qn it
>>> is necessarily correct because it is still true that the pure
>>> simulation of its input would never stop running.
>>>
>>
>> So if H IS a pure simulator, the correct answer is Non-Halting, but a
>> pure simulator will never abort itself to give that. H FAILS.
>>
>
> computation that halts
> ...the Turing machine will halt whenever it enters a final state.
> (Linz:1990:234)
>
> The fact that the input to embedded_H never reaches its final state
> whether or not its simulation is ever aborted conclusively proves that
> this input never halts therefore when embedded_H transitions to Ĥ.qn it
> is necessarily correct.
>

WRONG, because the ACTUAL Turing Machine that is represented in the
input WILL reach its final state, IF H aborts is simulation and goes to
H.qn, so H^ will also go to H^.qn, and thus Halt, and thus the UTM will
too. FAIL.

You can't argue about an H that never aborts, figure out what the system
does, and then change H. That invalidates the system you figured out.

Doesn't matter that you give H two names, the y all still must be the same.

It also isn't true that the 'input' to embedded_H never reaches its
final state whether or not its simulation is ever aborted. If embedded_H
aborts its simulation the Turing Machine the input represents DOES halt.
That is provable.

Only your mistaken idea that an aborted simulation that doesn't reach a
halting state is some sort of proof that the machine doesn't halt, or
that H has somehow 'Proven' the it won't halt before it does so makes a
difffernce. H's proof is incorrect, as obvious by the fact that even you
admit that directly running H^ applied to <H^> will halt.

Since H^ applied to <H^> Halts, this also means that UTM(<H^>,<H^>) does
actually halt too. If H aborts its simulation, it only does so based on
an INCORRECT pattern that it THINK is proof of non-halting, but actually
isn't.

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<Q5GdnaA9H6CzHlL8nZ2dnUU7-e3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 16:24:46 -0600
Date: Fri, 31 Dec 2021 16:24:40 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
<83KzJ.212093$1d1.209379@fx99.iad>
<BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
<MDKzJ.251382$IW4.243734@fx48.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <MDKzJ.251382$IW4.243734@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Q5GdnaA9H6CzHlL8nZ2dnUU7-e3NnZ2d@giganews.com>
Lines: 112
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-V1JuZcUpCY9SgmlPpELfg6T1btVb8xQOJ+jQ3j7ZVNyTejZXa6+Qfd/RD74fN+9HVaMeirqFSo1gGgt!kYJWIPp2Szb+0eP+MOh097WHzOJb0YSYgQXfolZQsLR7WY8/u4T2JHVtCC27XQ0x2ZzQU6Lgotck!6g==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6616
 by: olcott - Fri, 31 Dec 2021 22:24 UTC

On 12/31/2021 3:30 PM, Richard Damon wrote:
> On 12/31/21 3:59 PM, olcott wrote:
>> On 12/31/2021 2:51 PM, Richard Damon wrote:
>>> On 12/31/21 3:08 PM, olcott wrote:
>>>> On 12/31/2021 1:55 PM, Richard Damon wrote:
>>>>> On 12/31/21 2:46 PM, olcott wrote:
>>>>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of the UTM
>>>>>>>>>>>>>>> simulation of these inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you can't point to any mistakes that proves that you are
>>>>>>>>>>>>> the idiot
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> How about that it can be simple shown by inspection that if
>>>>>>>>>>>> H and embedded_H applied to <H^> <H^> goes to H.qn, then so
>>>>>>>>>>>> does H^ applied to <H^> go to H^.qn and Halts, thus H was
>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input
>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation
>>>>>>>>>>> of this input
>>>>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>>>>
>>>>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>>>>> (a) Its input halts on its own.
>>>>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Proven impossible for such an algorithm to decide H^ is
>>>>>>>>> non-halting:
>>>>>>>>
>>>>>>>> If is self-evidently true that unless simulating halt decider
>>>>>>>> embedded_H aborts the simulation of its input at some point that
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ never stops running.
>>>>>>>>
>>>>>>>> That you have never agreed to this proves that you are dishonest.
>>>>>>>>
>>>>>>>
>>>>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>>>>
>>>>>>> Thus, YES, if your H that doesn't abort its simulation until IT
>>>>>>> can correctly prove the computation is non-halting, H^ will be
>>>>>>> Non-Halting and that would be the correct answer, but H can not
>>>>>>> compute that answer, and will be non-halting itself.
>>>>>> Well that is a breakthrough.
>>>>>>
>>>>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn
>>>>>> even if embedded_H cannot compute this correct halt status.
>>>>>>
>>>>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>>>>>>
>>>>>>
>>>>>
>>>>> Right, the correct answer is Non-Halting but NEITHER H or
>>>>> embedded_H can give it, because if they do, it becomes the wrong
>>>>> answer.
>>>>>
>>>>
>>>> When embedded_H is basing its halt status decision on the behavior
>>>> pure simulation of its input then because the pure simulation of its
>>>> input would never stop running when embedded_H transitions to Ĥ.qn
>>>> it is necessarily correct because it is still true that the pure
>>>> simulation of its input would never stop running.
>>>>
>>>
>>> So if H IS a pure simulator, the correct answer is Non-Halting, but a
>>> pure simulator will never abort itself to give that. H FAILS.
>>>
>>
>> computation that halts
>> ...the Turing machine will halt whenever it enters a final state.
>> (Linz:1990:234)
>>
>> The fact that the input to embedded_H never reaches its final state
>> whether or not its simulation is ever aborted conclusively proves that
>> this input never halts therefore when embedded_H transitions to Ĥ.qn
>> it is necessarily correct.
>>
>
> WRONG, because the ACTUAL Turing Machine that is represented in the
> input WILL reach its final state,

This is why I need an actual computer scientist to review my work.

An actual computer scientist will understand that embedded_H does
compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
final state Ĥ.qn on the basis that the actual input would never halt.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<qELzJ.212635$1d1.152562@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
<83KzJ.212093$1d1.209379@fx99.iad>
<BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
<MDKzJ.251382$IW4.243734@fx48.iad>
<Q5GdnaA9H6CzHlL8nZ2dnUU7-e3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Q5GdnaA9H6CzHlL8nZ2dnUU7-e3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 134
Message-ID: <qELzJ.212635$1d1.152562@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 17:39:20 -0500
X-Received-Bytes: 7549
 by: Richard Damon - Fri, 31 Dec 2021 22:39 UTC

On 12/31/21 5:24 PM, olcott wrote:
> On 12/31/2021 3:30 PM, Richard Damon wrote:
>> On 12/31/21 3:59 PM, olcott wrote:
>>> On 12/31/2021 2:51 PM, Richard Damon wrote:
>>>> On 12/31/21 3:08 PM, olcott wrote:
>>>>> On 12/31/2021 1:55 PM, Richard Damon wrote:
>>>>>> On 12/31/21 2:46 PM, olcott wrote:
>>>>>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>>>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its
>>>>>>>>>>>>>>>> inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of
>>>>>>>>>>>>>>>> the UTM simulation of these inputs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you can't point to any mistakes that proves that you
>>>>>>>>>>>>>> are the idiot
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> How about that it can be simple shown by inspection that if
>>>>>>>>>>>>> H and embedded_H applied to <H^> <H^> goes to H.qn, then so
>>>>>>>>>>>>> does H^ applied to <H^> go to H^.qn and Halts, thus H was
>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its input
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure simulation
>>>>>>>>>>>> of this input
>>>>>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>>>>>
>>>>>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>>>>>> (a) Its input halts on its own.
>>>>>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Proven impossible for such an algorithm to decide H^ is
>>>>>>>>>> non-halting:
>>>>>>>>>
>>>>>>>>> If is self-evidently true that unless simulating halt decider
>>>>>>>>> embedded_H aborts the simulation of its input at some point
>>>>>>>>> that Ĥ applied to ⟨Ĥ⟩ never stops running.
>>>>>>>>>
>>>>>>>>> That you have never agreed to this proves that you are dishonest.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>>>>>
>>>>>>>> Thus, YES, if your H that doesn't abort its simulation until IT
>>>>>>>> can correctly prove the computation is non-halting, H^ will be
>>>>>>>> Non-Halting and that would be the correct answer, but H can not
>>>>>>>> compute that answer, and will be non-halting itself.
>>>>>>> Well that is a breakthrough.
>>>>>>>
>>>>>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ.qn
>>>>>>> even if embedded_H cannot compute this correct halt status.
>>>>>>>
>>>>>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong answer.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, the correct answer is Non-Halting but NEITHER H or
>>>>>> embedded_H can give it, because if they do, it becomes the wrong
>>>>>> answer.
>>>>>>
>>>>>
>>>>> When embedded_H is basing its halt status decision on the behavior
>>>>> pure simulation of its input then because the pure simulation of
>>>>> its input would never stop running when embedded_H transitions to
>>>>> Ĥ.qn it is necessarily correct because it is still true that the
>>>>> pure simulation of its input would never stop running.
>>>>>
>>>>
>>>> So if H IS a pure simulator, the correct answer is Non-Halting, but
>>>> a pure simulator will never abort itself to give that. H FAILS.
>>>>
>>>
>>> computation that halts
>>> ...the Turing machine will halt whenever it enters a final state.
>>> (Linz:1990:234)
>>>
>>> The fact that the input to embedded_H never reaches its final state
>>> whether or not its simulation is ever aborted conclusively proves
>>> that this input never halts therefore when embedded_H transitions to
>>> Ĥ.qn it is necessarily correct.
>>>
>>
>> WRONG, because the ACTUAL Turing Machine that is represented in the
>> input WILL reach its final state,
>
> This is why I need an actual computer scientist to review my work.
>
> An actual computer scientist will understand that embedded_H does
> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
> final state Ĥ.qn on the basis that the actual input would never halt.
>
>

Nope, you need someone who understands the logic.

IF H computes the mapping of <H^><H^> -> Qn
then H^ (<H^>) Will halt and the mapping will be wrong as it doesn't
match the acutal halting funciton.

IF H never aborts and returns an answer, then yes, Halt(H^(<H^>)) will
be Halting, but H fails by not returning it.

The problem that you are missing is that while you have a sketch of an
algorithm, simulate until you reach a pattern that indicates a provable
non-halting pattern, then abort the simulation and go to Qn. This sketch
needs a data set of patterns, but such a data set can not be finite and
complete so the algorithm doesn't actually work.

As I have proved before, there is NO pattern that H or embedded_H can
use to detect that the machine it is simulating will be non-halting.

Note, the condition isn't non-halting if H doesn't abort it, the test is
the input needs to be non-halting.

Once you actually have an H defined that you are testing, H will do what
H is programmed to do, and that H needs to generate an answer based on
if the computation will halt or not, including the behavior of the copy
of H in it.

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<b7OdnWfGtoBlEVL8nZ2dnUU7-eHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 17:06:32 -0600
Date: Fri, 31 Dec 2021 17:06:31 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
<83KzJ.212093$1d1.209379@fx99.iad>
<BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
<MDKzJ.251382$IW4.243734@fx48.iad>
<Q5GdnaA9H6CzHlL8nZ2dnUU7-e3NnZ2d@giganews.com>
<qELzJ.212635$1d1.152562@fx99.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <qELzJ.212635$1d1.152562@fx99.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <b7OdnWfGtoBlEVL8nZ2dnUU7-eHNnZ2d@giganews.com>
Lines: 128
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9B9oo0xtT95B+/sCw/9vdY322V0FI0w5quBittpHtDFZbxk2KzXURA1WocmQJxLzUh/DCdaJvCitVvK!WZ9oW2uI/LS75tkHUBaDuaxYs+IDkgH8MvwGSj+yKDJoObCZ64h83jkDq0pfJjzDVGAaC2oHCjSn!xQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7336
 by: olcott - Fri, 31 Dec 2021 23:06 UTC

On 12/31/2021 4:39 PM, Richard Damon wrote:
>
> On 12/31/21 5:24 PM, olcott wrote:
>> On 12/31/2021 3:30 PM, Richard Damon wrote:
>>> On 12/31/21 3:59 PM, olcott wrote:
>>>> On 12/31/2021 2:51 PM, Richard Damon wrote:
>>>>> On 12/31/21 3:08 PM, olcott wrote:
>>>>>> On 12/31/2021 1:55 PM, Richard Damon wrote:
>>>>>>> On 12/31/21 2:46 PM, olcott wrote:
>>>>>>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>>>>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>>>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its
>>>>>>>>>>>>>>>>> inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of
>>>>>>>>>>>>>>>>> the UTM simulation of these inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you can't point to any mistakes that proves that you
>>>>>>>>>>>>>>> are the idiot
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How about that it can be simple shown by inspection that
>>>>>>>>>>>>>> if H and embedded_H applied to <H^> <H^> goes to H.qn,
>>>>>>>>>>>>>> then so does H^ applied to <H^> go to H^.qn and Halts,
>>>>>>>>>>>>>> thus H was WRONG.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its
>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure
>>>>>>>>>>>>> simulation of this input
>>>>>>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>>>>>>
>>>>>>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>>>>>>> (a) Its input halts on its own.
>>>>>>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Proven impossible for such an algorithm to decide H^ is
>>>>>>>>>>> non-halting:
>>>>>>>>>>
>>>>>>>>>> If is self-evidently true that unless simulating halt decider
>>>>>>>>>> embedded_H aborts the simulation of its input at some point
>>>>>>>>>> that Ĥ applied to ⟨Ĥ⟩ never stops running.
>>>>>>>>>>
>>>>>>>>>> That you have never agreed to this proves that you are dishonest.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>>>>>>
>>>>>>>>> Thus, YES, if your H that doesn't abort its simulation until IT
>>>>>>>>> can correctly prove the computation is non-halting, H^ will be
>>>>>>>>> Non-Halting and that would be the correct answer, but H can not
>>>>>>>>> compute that answer, and will be non-halting itself.
>>>>>>>> Well that is a breakthrough.
>>>>>>>>
>>>>>>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>> Ĥ.qn even if embedded_H cannot compute this correct halt status.
>>>>>>>>
>>>>>>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong
>>>>>>>> answer.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, the correct answer is Non-Halting but NEITHER H or
>>>>>>> embedded_H can give it, because if they do, it becomes the wrong
>>>>>>> answer.
>>>>>>>
>>>>>>
>>>>>> When embedded_H is basing its halt status decision on the behavior
>>>>>> pure simulation of its input then because the pure simulation of
>>>>>> its input would never stop running when embedded_H transitions to
>>>>>> Ĥ.qn it is necessarily correct because it is still true that the
>>>>>> pure simulation of its input would never stop running.
>>>>>>
>>>>>
>>>>> So if H IS a pure simulator, the correct answer is Non-Halting, but
>>>>> a pure simulator will never abort itself to give that. H FAILS.
>>>>>
>>>>
>>>> computation that halts
>>>> ...the Turing machine will halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>>
>>>> The fact that the input to embedded_H never reaches its final state
>>>> whether or not its simulation is ever aborted conclusively proves
>>>> that this input never halts therefore when embedded_H transitions to
>>>> Ĥ.qn it is necessarily correct.
>>>>
>>>
>>> WRONG, because the ACTUAL Turing Machine that is represented in the
>>> input WILL reach its final state,
>>
>> This is why I need an actual computer scientist to review my work.
>>
>> An actual computer scientist will understand that embedded_H does
>> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
>> final state Ĥ.qn on the basis that the actual input would never halt.
>>
>>
>
> Nope, you need someone who understands the logic.
>

When we know that an animal is a cat then when this cat barks or gives
birth to puppies it is still a cat.

When we know that the input to embedded_H never halts then we know that
when embedded_H transitions to Ĥ.qn this does correctly report the halt
status of its actual input.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V43 [where people get stuck]

<9vMzJ.52155$bn2.11488@fx12.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V43 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <AIednc_gnYHyslL8nZ2dnUU7-IPNnZ2d@giganews.com>
<sqnb4c$1nl5$1@gioia.aioe.org>
<9cidnfUHUv_grVL8nZ2dnUU7-XudnZ2d@giganews.com>
<wHGzJ.52272$bo.39043@fx18.iad>
<FIGdneWXW9MzplL8nZ2dnUU7-cfNnZ2d@giganews.com>
<oeWdnSH1X74-2VL8nZ2dnUU7-IWdnZ2d@giganews.com>
<bkIzJ.69800$xe2.62705@fx16.iad>
<pNidnReiDYTMyFL8nZ2dnUU7-VvNnZ2d@giganews.com>
<2PIzJ.95859$Gco3.18861@fx01.iad>
<eoKdnRUNgN-Aw1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<weJzJ.52153$bn2.36806@fx12.iad>
<EeCdneJ1iJHf_lL8nZ2dnUU7-N3NnZ2d@giganews.com>
<83KzJ.212093$1d1.209379@fx99.iad>
<BbmdnZ-ygveK8lL8nZ2dnUU7-RfNnZ2d@giganews.com>
<MDKzJ.251382$IW4.243734@fx48.iad>
<Q5GdnaA9H6CzHlL8nZ2dnUU7-e3NnZ2d@giganews.com>
<qELzJ.212635$1d1.152562@fx99.iad>
<b7OdnWfGtoBlEVL8nZ2dnUU7-eHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <b7OdnWfGtoBlEVL8nZ2dnUU7-eHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 141
Message-ID: <9vMzJ.52155$bn2.11488@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 18:37:43 -0500
X-Received-Bytes: 7672
X-Original-Bytes: 7539
 by: Richard Damon - Fri, 31 Dec 2021 23:37 UTC

On 12/31/21 6:06 PM, olcott wrote:
> On 12/31/2021 4:39 PM, Richard Damon wrote:
>>
>> On 12/31/21 5:24 PM, olcott wrote:
>>> On 12/31/2021 3:30 PM, Richard Damon wrote:
>>>> On 12/31/21 3:59 PM, olcott wrote:
>>>>> On 12/31/2021 2:51 PM, Richard Damon wrote:
>>>>>> On 12/31/21 3:08 PM, olcott wrote:
>>>>>>> On 12/31/2021 1:55 PM, Richard Damon wrote:
>>>>>>>> On 12/31/21 2:46 PM, olcott wrote:
>>>>>>>>> On 12/31/2021 1:25 PM, Richard Damon wrote:
>>>>>>>>>> On 12/31/21 2:09 PM, olcott wrote:
>>>>>>>>>>> On 12/31/2021 12:52 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/31/21 12:57 PM, olcott wrote:
>>>>>>>>>>>>> On 12/31/2021 11:19 AM, olcott wrote:
>>>>>>>>>>>>>> On 12/31/2021 11:01 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 12/31/21 11:31 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 12/31/2021 10:28 AM, Steve Parker wrote:
>>>>>>>>>>>>>>>>> On 12/31/2021 8:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> Proving that embedded_H at Ĥ.qx correctly maps its
>>>>>>>>>>>>>>>>>> inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis of the behavior of
>>>>>>>>>>>>>>>>>> the UTM simulation of these inputs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Shut up idiot.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you can't point to any mistakes that proves that you
>>>>>>>>>>>>>>>> are the idiot
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How about that it can be simple shown by inspection that
>>>>>>>>>>>>>>> if H and embedded_H applied to <H^> <H^> goes to H.qn,
>>>>>>>>>>>>>>> then so does H^ applied to <H^> go to H^.qn and Halts,
>>>>>>>>>>>>>>> thus H was WRONG.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> embedded_H at Ĥ.qx is only accountable for mapping its
>>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis that a pure
>>>>>>>>>>>>>> simulation of this input
>>>>>>>>>>>>>> (no embedded_H ever aborts the simulation of its input).
>>>>>>>>>>>>>
>>>>>>>>>>>>> No embedded_H ever aborts the simulation of its input until:
>>>>>>>>>>>>> (a) Its input halts on its own.
>>>>>>>>>>>>> (b) It detects that its input would never halt on its own.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Proven impossible for such an algorithm to decide H^ is
>>>>>>>>>>>> non-halting:
>>>>>>>>>>>
>>>>>>>>>>> If is self-evidently true that unless simulating halt decider
>>>>>>>>>>> embedded_H aborts the simulation of its input at some point
>>>>>>>>>>> that Ĥ applied to ⟨Ĥ⟩ never stops running.
>>>>>>>>>>>
>>>>>>>>>>> That you have never agreed to this proves that you are
>>>>>>>>>>> dishonest.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And YOU don't understand that no ALGORITHM can detect this.
>>>>>>>>>>
>>>>>>>>>> Thus, YES, if your H that doesn't abort its simulation until
>>>>>>>>>> IT can correctly prove the computation is non-halting, H^ will
>>>>>>>>>> be Non-Halting and that would be the correct answer, but H can
>>>>>>>>>> not compute that answer, and will be non-halting itself.
>>>>>>>>> Well that is a breakthrough.
>>>>>>>>>
>>>>>>>>> The correct halt status for embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>> Ĥ.qn even if embedded_H cannot compute this correct halt status.
>>>>>>>>>
>>>>>>>>> Prior to this breakthrough both Ĥ.qy and Ĥ.qn were the wrong
>>>>>>>>> answer.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, the correct answer is Non-Halting but NEITHER H or
>>>>>>>> embedded_H can give it, because if they do, it becomes the wrong
>>>>>>>> answer.
>>>>>>>>
>>>>>>>
>>>>>>> When embedded_H is basing its halt status decision on the
>>>>>>> behavior pure simulation of its input then because the pure
>>>>>>> simulation of its input would never stop running when embedded_H
>>>>>>> transitions to Ĥ.qn it is necessarily correct because it is still
>>>>>>> true that the pure simulation of its input would never stop running.
>>>>>>>
>>>>>>
>>>>>> So if H IS a pure simulator, the correct answer is Non-Halting,
>>>>>> but a pure simulator will never abort itself to give that. H FAILS.
>>>>>>
>>>>>
>>>>> computation that halts
>>>>> ...the Turing machine will halt whenever it enters a final state.
>>>>> (Linz:1990:234)
>>>>>
>>>>> The fact that the input to embedded_H never reaches its final state
>>>>> whether or not its simulation is ever aborted conclusively proves
>>>>> that this input never halts therefore when embedded_H transitions
>>>>> to Ĥ.qn it is necessarily correct.
>>>>>
>>>>
>>>> WRONG, because the ACTUAL Turing Machine that is represented in the
>>>> input WILL reach its final state,
>>>
>>> This is why I need an actual computer scientist to review my work.
>>>
>>> An actual computer scientist will understand that embedded_H does
>>> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
>>> final state Ĥ.qn on the basis that the actual input would never halt.
>>>
>>>
>>
>> Nope, you need someone who understands the logic.
>>
>
> When we know that an animal is a cat then when this cat barks or gives
> birth to puppies it is still a cat.
>
> When we know that the input to embedded_H never halts then we know that
> when embedded_H transitions to Ĥ.qn this does correctly report the halt
> status of its actual input.
>
>

And we know that if H goes to H.qn, H^ also goes to H^.qn, and Halt, so
H was WRONG.

The input to embedded_H never halts ONLY if embedded_H doesn't go to Qn.

The criteria for the Halt Decider is NOT will the input never halt
unless the decider aborts its simulation, it is will the actual Machine
never Halt when run, or equivalently, will the UTM never halt. (it
doesn't matter what happen inside the decider).

There is no 'unless the decider aborts' in the definition.

That is a Olcott misdefinition, because he confuses his decider with the
UTM that checks it.

FAIL.

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor