Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

On the eighth day, God created FORTRAN.


devel / comp.theory / Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

SubjectAuthor
* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
+- Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
+* Concise refutation of halting problem proofs V62 [ Linz Proof ]dklei...@gmail.com
|+- Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|`* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
| `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|  `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|   `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|    `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|     `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|      `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|       `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|        `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|         `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|          `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|           `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|            `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|             +* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |`* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|             | `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |  `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|             |   `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |    +* Concise refutation of halting problem proofs V62 [ Linz Proof ]Python
|             |    |+* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|             |    ||`- Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |    |`- Concise refutation of halting problem proofs V62 [ Linz Proof ]B.H.
|             |    `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |     `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|             |      `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |       `* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|             |        `* Concise refutation of halting problem proofs V62 [ Linz Proof ]Richard Damon
|             |         `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |          +* Concise refutation of halting problem proofs V62 [ misconceptionsPython
|             |          |`* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |          | `- Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |          `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |           `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |            `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |             `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |              `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |               `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                 `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                  `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                   `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                    `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                     `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                      `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                       `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                        `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                         `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                          `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                           `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                            `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                             `* Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             |                              `* Concise refutation of halting problem proofs V62 [ misconceptionsRichard Damon
|             |                               `* Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|             |                                `* Concise refutation of halting problem proofs V62 [ self-evident ]Richard Damon
|             |                                 `* Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|             |                                  `* Concise refutation of halting problem proofs V62 [ self-evident ]Richard Damon
|             |                                   `- Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|             `* Concise refutation of halting problem proofs V62 [ Linz Proof ]( application to olcott
|              `- Concise refutation of halting problem proofs V62 [ Linz Proof ](Richard Damon
`* Concise refutation of halting problem proofs V62 [ self-evident ]olcott
 +* Concise refutation of halting problem proofs V62 [ self-evident ]Richard Damon
 |`* Concise refutation of halting problem proofs V62 [ self-evident ]olcott
 | `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |  `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |   `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |    `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |     `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |      `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |       `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |        `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |         `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |          `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |           `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |            `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |             `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |              `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |               `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |                `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |                 `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |                  `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |                   `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |                    `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |                     `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |                      `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |                       `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |                        `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 |                         `* Concise refutation of halting problem proofs V62 [ self-evidentRichard Damon
 |                          +* Concise refutation of halting problem proofs V62 [ self-evidentMr Flibble
 |                          |+* Concise refutation of halting problem proofs V62 [ self-evidentPython
 |                          ||`* Concise refutation of halting problem proofs V62 [ self-evidentMr Flibble
 |                          || `- Concise refutation of halting problem proofs V62 [ self-evident ](typo)wij
 |                          |`* Concise refutation of halting problem proofs V62 [ my legacy ]olcott
 |                          | +* Concise refutation of halting problem proofs V62 [ my legacy ]Mr Flibble
 |                          | |+* Concise refutation of halting problem proofs V62 [ my legacy ]olcott
 |                          | ||`- Concise refutation of halting problem proofs V62 [ my legacy ]Richard Damon
 |                          | |`- Concise refutation of halting problem proofs V62 [ my legacy ]Richard Damon
 |                          | +* Concise refutation of halting problem proofs V62 [ my legacy ]Mr Flibble
 |                          | +* Concise refutation of halting problem proofs V62 [ my legacy ]Python
 |                          | `* Concise refutation of halting problem proofs V62 [ my legacy ]Richard Damon
 |                          `* Concise refutation of halting problem proofs V62 [ self-evidentolcott
 `- Concise refutation of halting problem proofs V62 [ self-evident ]Richard Damon

Pages:1234567
Concise refutation of halting problem proofs V62 [ Linz Proof ]

<vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>

 copy mid

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

 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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 06 Feb 2022 10:31:34 -0600
Date: Sun, 6 Feb 2022 10:31:34 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.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 V62 [ Linz Proof ]
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
Lines: 56
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YOgEDeYfPTvTr/f2ZBDC9uw1ARWwPH4erAbbdYVk0QTCN1H2MV9zxAqpwIur/WNdSmJ2fNHwjX3xka8!Zj/Gs6hOUxDZr78FFdWjo16t3hbIfmHK98y8eWEbchKRGSrEV9Lv+QPTlp03fgRtSyjfHN/0TAHY
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: 3763
 by: olcott - Sun, 6 Feb 2022 16:31 UTC

Halting problem undecidability and infinitely nested simulation (V3)

Linz H is defined as simulating halt decider that bases its halt status
decision on whether or not its correct simulation of its input could
ever reach the final state of this simulated input.

H determines this on the basis of matching infinite behavior patterns.
When an infinite behavior pattern is matched H aborts its simulation and
transitions to its final reject state. Otherwise H transitions to its
accept state when its simulation ends.

The following simplifies the syntax for the definition of the Linz
Turing machine Ĥ, it is now a single machine with a single start state.
A copy of Linz H is embedded at Ĥ.qx.

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

Can the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H possibly transition
to ⟨Ĥ⟩.qn ?

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

The above repeating pattern shows that the correctly simulated input to
embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
proving that this simulated input never halts. This enables embedded_H
to abort its simulation and correctly transition to Ĥ.qn.

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correctly
simulated input could ever reach its final state: ⟨Ĥ⟩⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.

embedded_H is only accountable for the behavior of its correctly
simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩. embedded_H is not accountable for the behavior
of the computation that it is contained within: Ĥ applied to ⟨Ĥ⟩ because
is it not actual input to embedded_H.

*Halting problem undecidability and infinitely nested simulation (V3)*
https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
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 V62 [ Linz Proof ]

<noULJ.7702$K0Ga.962@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 73
Message-ID: <noULJ.7702$K0Ga.962@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 6 Feb 2022 13:25:24 -0500
X-Received-Bytes: 4134
 by: Richard Damon - Sun, 6 Feb 2022 18:25 UTC

Same wrong definitions and bad arguements.

NO showing where the previous PROOF that you were wrong was incorrect.

SO STILL UNSOUND LOGIC.

FAIL.

The quick summary:
Thie infinite loop claimed only appears if H is just a UTM and never
aborts, and such an H fails to be a decider because it never answers.

If H does abort is simulation, then the pattern does get aborted and
isn't infinite, dispite your ungrounded claim.

Remember, as 'simulator' that aborts before reaching the end state is
NOT a UTM and can't be considered one for any proof.

FAIL.

On 2/6/22 11:31 AM, olcott wrote:
> Halting problem undecidability and infinitely nested simulation (V3)
>
> Linz H is defined as simulating halt decider that bases its halt status
> decision on whether or not its correct simulation of its input could
> ever reach the final state of this simulated input.
>
> H determines this on the basis of matching infinite behavior patterns.
> When an infinite behavior pattern is matched H aborts its simulation and
> transitions to its final reject state. Otherwise H transitions to its
> accept state when its simulation ends.
>
> The following simplifies the syntax for the definition of the Linz
> Turing machine Ĥ, it is now a single machine with a single start state.
> A copy of Linz H is embedded at Ĥ.qx.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Can the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H possibly transition
> to ⟨Ĥ⟩.qn ?
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> The above repeating pattern shows that the correctly simulated input to
> embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
> proving that this simulated input never halts. This enables embedded_H
> to abort its simulation and correctly transition to Ĥ.qn.
>
> Because all simulating halt deciders are deciders they are only
> accountable for computing the mapping from their input finite strings to
> an accept or reject state on the basis of whether or not their correctly
> simulated input could ever reach its final state: ⟨Ĥ⟩⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>
> embedded_H is only accountable for the behavior of its correctly
> simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩. embedded_H is not accountable for the behavior
> of the computation that it is contained within: Ĥ applied to ⟨Ĥ⟩ because
> is it not actual input to embedded_H.
>
>
>
> *Halting problem undecidability and infinitely nested simulation (V3)*
> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:d4c:: with SMTP id 12mr8318565qvr.57.1644176595242;
Sun, 06 Feb 2022 11:43:15 -0800 (PST)
X-Received: by 2002:a25:eb0d:: with SMTP id d13mr5660083ybs.562.1644176595079;
Sun, 06 Feb 2022 11:43:15 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!nntp.club.cc.cmu.edu!5.161.45.24.MISMATCH!2.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sun, 6 Feb 2022 11:43:14 -0800 (PST)
In-Reply-To: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=47.208.151.23; posting-account=7Xc2EwkAAABXMcQfERYamr3b-64IkBws
NNTP-Posting-Host: 47.208.151.23
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: dkleine...@gmail.com (dklei...@gmail.com)
Injection-Date: Sun, 06 Feb 2022 19:43:15 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 14
 by: dklei...@gmail.com - Sun, 6 Feb 2022 19:43 UTC

On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>
> H determines [halting] on the basis of matching infinite behavior patterns.
> When an infinite behavior pattern is matched H aborts its simulation and
> transitions to its final reject state. Otherwise H transitions to its
> accept state when its simulation ends.
>
This is incomplete because it does not cover the case where the
machine neither halts nor matches an "infinite behavior pattern".

You need to prove a theorem: There is a finite set of patterns such
that every Turing machine either halts or matches one of these
patterns.

But I feel sure that theorem is not true.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<FHVLJ.10306$r6p7.6706@fx41.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!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!fx41.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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 24
Message-ID: <FHVLJ.10306$r6p7.6706@fx41.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: Sun, 6 Feb 2022 14:54:14 -0500
X-Received-Bytes: 2046
 by: Richard Damon - Sun, 6 Feb 2022 19:54 UTC

On 2/6/22 2:43 PM, dklei...@gmail.com wrote:
> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>
>> H determines [halting] on the basis of matching infinite behavior patterns.
>> When an infinite behavior pattern is matched H aborts its simulation and
>> transitions to its final reject state. Otherwise H transitions to its
>> accept state when its simulation ends.
>>
> This is incomplete because it does not cover the case where the
> machine neither halts nor matches an "infinite behavior pattern".
>
> You need to prove a theorem: There is a finite set of patterns such
> that every Turing machine either halts or matches one of these
> patterns.
>
> But I feel sure that theorem is not true.

Actually, I have shown that there is no pattern for H to detect that
shows that H^ applied to <H^> is non-halting, if H would use it.

But if H doesn't abort H^ applied to <H^> then it does become
non-halting, which shows that there is no such finite set of finite
patterns.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<stpa86$hib$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Followup-To: comp.theory
Date: Sun, 6 Feb 2022 14:15:01 -0600
Organization: A noiseless patient Spider
Lines: 30
Message-ID: <stpa86$hib$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 6 Feb 2022 20:15:02 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="18c1063ccfb1605a88f6106a8abd380e";
logging-data="17995"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/VJjh/iZZYV5KcmetAW3SK"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:cAsF8PxeQ7fXHCwF41PImhbg6pc=
In-Reply-To: <d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
Content-Language: en-US
 by: olcott - Sun, 6 Feb 2022 20:15 UTC

On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>
>> H determines [halting] on the basis of matching infinite behavior patterns.
>> When an infinite behavior pattern is matched H aborts its simulation and
>> transitions to its final reject state. Otherwise H transitions to its
>> accept state when its simulation ends.
>>
> This is incomplete because it does not cover the case where the
> machine neither halts nor matches an "infinite behavior pattern".
>

It covers the case that had previously been considered to be proof that
the halting problem is undecidable. That is all that I need to refute
these proofs.

> You need to prove a theorem: There is a finite set of patterns such
> that every Turing machine either halts or matches one of these
> patterns.
>
> But I feel sure that theorem is not true.

To solve the halting problem my program must be all knowing. To refute
the proofs I merely need to show that their counter-example can be
proved to 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 V62 [ Linz Proof ]

<UgWLJ.9101$GjY3.7596@fx01.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <stpa86$hib$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 44
Message-ID: <UgWLJ.9101$GjY3.7596@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: Sun, 6 Feb 2022 15:33:57 -0500
X-Received-Bytes: 2926
 by: Richard Damon - Sun, 6 Feb 2022 20:33 UTC

On 2/6/22 3:15 PM, olcott wrote:
> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>
>>> H determines [halting] on the basis of matching infinite behavior
>>> patterns.
>>> When an infinite behavior pattern is matched H aborts its simulation and
>>> transitions to its final reject state. Otherwise H transitions to its
>>> accept state when its simulation ends.
>>>
>> This is incomplete because it does not cover the case where the
>> machine neither halts nor matches an "infinite behavior pattern".
>>
>
> It covers the case that had previously been considered to be proof that
> the halting problem is undecidable. That is all that I need to refute
> these proofs.
>
>> You need to prove a theorem: There is a finite set of patterns such
>> that every Turing machine either halts or matches one of these
>> patterns.
>>
>> But I feel sure that theorem is not true.
>
> To solve the halting problem my program must be all knowing. To refute
> the proofs I merely need to show that their counter-example can be
> proved to never halt.
>

And you just ignore the fact that if H applied to <H^> <H^> goes to
H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts, and since
H, to be an accurate Halt Decider, must only go to H,Qn if the machine
its input represents will never halt. They you also don't seem to
understand that the computaton that <H^> <H^> represents IS H^ applied
to <H^>. So, H was just wrong.

So, you haven't actually proved the thing you claim youhave, but only
that you have amassed an amazing pile of unsound logic based on wrong
definitions that have hoodwinked yourself into thinking you have shown
something useful.

You are so good at doing this that you have gaslighted yourself so you
can't actually understand what actual Truth is.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>

 copy mid

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

 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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 06 Feb 2022 14:53:55 -0600
Date: Sun, 6 Feb 2022 14:53:55 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <UgWLJ.9101$GjY3.7596@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
Lines: 74
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4iwHwPD6BbMUJZM/eNLYiNCA35iSPxYY603ce7vcjmi2dd9HtLGogdD05t9DzU/PK2s0w172E4bONrt!jxFQOot/r90BsR/QURrh0i6Ou5crk4Mxo23X8xYMZortJ4E1ZBGl8TwOf3QyT2obCmi1FnK8b3Q4
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: 4302
 by: olcott - Sun, 6 Feb 2022 20:53 UTC

On 2/6/2022 2:33 PM, Richard Damon wrote:
> On 2/6/22 3:15 PM, olcott wrote:
>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>
>>>> H determines [halting] on the basis of matching infinite behavior
>>>> patterns.
>>>> When an infinite behavior pattern is matched H aborts its simulation
>>>> and
>>>> transitions to its final reject state. Otherwise H transitions to its
>>>> accept state when its simulation ends.
>>>>
>>> This is incomplete because it does not cover the case where the
>>> machine neither halts nor matches an "infinite behavior pattern".
>>>
>>
>> It covers the case that had previously been considered to be proof
>> that the halting problem is undecidable. That is all that I need to
>> refute these proofs.
>>
>>> You need to prove a theorem: There is a finite set of patterns such
>>> that every Turing machine either halts or matches one of these
>>> patterns.
>>>
>>> But I feel sure that theorem is not true.
>>
>> To solve the halting problem my program must be all knowing. To refute
>> the proofs I merely need to show that their counter-example can be
>> proved to never halt.
>>
>
> And you just ignore the fact that if H applied to <H^> <H^> goes to
> H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts, and since
> H, to be an accurate Halt Decider, must only go to H,Qn if the machine
> its input represents will never halt. They you also don't seem to
> understand that the computaton that <H^> <H^> represents IS H^ applied
> to <H^>. So, H was just wrong.
>
> So, you haven't actually proved the thing you claim youhave, but only
> that you have amassed an amazing pile of unsound logic based on wrong
> definitions that have hoodwinked yourself into thinking you have shown
> something useful.
>
> You are so good at doing this that you have gaslighted yourself so you
> can't actually understand what actual Truth is.
>

You simply do know know enough computer science to understand that you
are wrong and never will because you believe that you are right.

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correctly
simulated input could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.

Can the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H possibly transition
to ⟨Ĥ⟩.qn ?

Halting problem undecidability and infinitely nested simulation (V3)

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
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 V62 [ Linz Proof ]

<feXLJ.39132$%uX7.7402@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 110
Message-ID: <feXLJ.39132$%uX7.7402@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 6 Feb 2022 16:39:24 -0500
X-Received-Bytes: 5284
 by: Richard Damon - Sun, 6 Feb 2022 21:39 UTC

On 2/6/22 3:53 PM, olcott wrote:
> On 2/6/2022 2:33 PM, Richard Damon wrote:
>> On 2/6/22 3:15 PM, olcott wrote:
>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>
>>>>> H determines [halting] on the basis of matching infinite behavior
>>>>> patterns.
>>>>> When an infinite behavior pattern is matched H aborts its
>>>>> simulation and
>>>>> transitions to its final reject state. Otherwise H transitions to its
>>>>> accept state when its simulation ends.
>>>>>
>>>> This is incomplete because it does not cover the case where the
>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>
>>>
>>> It covers the case that had previously been considered to be proof
>>> that the halting problem is undecidable. That is all that I need to
>>> refute these proofs.
>>>
>>>> You need to prove a theorem: There is a finite set of patterns such
>>>> that every Turing machine either halts or matches one of these
>>>> patterns.
>>>>
>>>> But I feel sure that theorem is not true.
>>>
>>> To solve the halting problem my program must be all knowing. To
>>> refute the proofs I merely need to show that their counter-example
>>> can be proved to never halt.
>>>
>>
>> And you just ignore the fact that if H applied to <H^> <H^> goes to
>> H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts, and since
>> H, to be an accurate Halt Decider, must only go to H,Qn if the machine
>> its input represents will never halt. They you also don't seem to
>> understand that the computaton that <H^> <H^> represents IS H^ applied
>> to <H^>. So, H was just wrong.
>>
>> So, you haven't actually proved the thing you claim youhave, but only
>> that you have amassed an amazing pile of unsound logic based on wrong
>> definitions that have hoodwinked yourself into thinking you have shown
>> something useful.
>>
>> You are so good at doing this that you have gaslighted yourself so you
>> can't actually understand what actual Truth is.
>>
>
> You simply do know know enough computer science to understand that you
> are wrong and never will because you believe that you are right.
>

And you clearly don't know enough Computation Theory to talk about it.

Since the is a Theorm in Computation Theory, using Computation Theory
Deffinitions, that is your problem.
>
>
> Because all simulating halt deciders are deciders they are only
> accountable for computing the mapping from their input finite strings to
> an accept or reject state on the basis of whether or not their correctly
> simulated input could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.

And if you are working on the Halting Problem of Computation Theory, BY
DEFINITION, the meaning of 'correcty simulted' is simulation by a REAL
UTM which BY DEFINITION exactly matches the behavior of Computation that
it is representation of, which for <H^> <H^> is H^ applied to <H^>

Since you claim otherwise, you are just a liar.

Can you actually provide a reputable source for your definition?
Something that allows for you incomplete simulation to be proof of
non-haling?

DID THINK SO.

LAIR!

>
> Can the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H possibly transition
> to ⟨Ĥ⟩.qn ?
>

Doesn't matter, since embedded_H isn't a UTM (or if it is, it doesn't
answer so fails to be the decider).

So, by applying the wrong criteria, you just admitted that you aren't
working in the field of Computation Theory.

FAIL.

>
> Halting problem undecidability and infinitely nested simulation (V3)
>
> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>
>
>

Again, you have just proved that you are just lying about working on the
Halting Problem of Computation Theory as you fail to use the actual
definition from that field. That or you are just a moron and don't know
a thing about the field, and are just lying about knowing about it.

FAIL.

BY DEFINITION.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

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

 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: Sun, 06 Feb 2022 21:04:54 -0600
Date: Sun, 6 Feb 2022 21:04:53 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <feXLJ.39132$%uX7.7402@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 91
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-RHhwe1EeROKKzn8n56LeXsU587Q66v3U9OTEdVEVLIFbJzJl5tCLvJu+jMcWnkNspJkAroD27mrfLKd!3KK3yq62dRIsRPpj3oksIVi72BQP5+xkPmOYIjG75nUJxB4+G2cHWV2Wq7Q4OsQ7Ztq/Ztg/YCYb
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: 5376
 by: olcott - Mon, 7 Feb 2022 03:04 UTC

On 2/6/2022 3:39 PM, Richard Damon wrote:
>
> On 2/6/22 3:53 PM, olcott wrote:
>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>> On 2/6/22 3:15 PM, olcott wrote:
>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>
>>>>>> H determines [halting] on the basis of matching infinite behavior
>>>>>> patterns.
>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>> simulation and
>>>>>> transitions to its final reject state. Otherwise H transitions to its
>>>>>> accept state when its simulation ends.
>>>>>>
>>>>> This is incomplete because it does not cover the case where the
>>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>>
>>>>
>>>> It covers the case that had previously been considered to be proof
>>>> that the halting problem is undecidable. That is all that I need to
>>>> refute these proofs.
>>>>
>>>>> You need to prove a theorem: There is a finite set of patterns such
>>>>> that every Turing machine either halts or matches one of these
>>>>> patterns.
>>>>>
>>>>> But I feel sure that theorem is not true.
>>>>
>>>> To solve the halting problem my program must be all knowing. To
>>>> refute the proofs I merely need to show that their counter-example
>>>> can be proved to never halt.
>>>>
>>>
>>> And you just ignore the fact that if H applied to <H^> <H^> goes to
>>> H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts, and
>>> since H, to be an accurate Halt Decider, must only go to H,Qn if the
>>> machine its input represents will never halt. They you also don't
>>> seem to understand that the computaton that <H^> <H^> represents IS
>>> H^ applied to <H^>. So, H was just wrong.
>>>
>>> So, you haven't actually proved the thing you claim youhave, but only
>>> that you have amassed an amazing pile of unsound logic based on wrong
>>> definitions that have hoodwinked yourself into thinking you have
>>> shown something useful.
>>>
>>> You are so good at doing this that you have gaslighted yourself so
>>> you can't actually understand what actual Truth is.
>>>
>>
>> You simply do know know enough computer science to understand that you
>> are wrong and never will because you believe that you are right.
>>
>
> And you clearly don't know enough Computation Theory to talk about it.
>
> Since the is a Theorm in Computation Theory, using Computation Theory
> Deffinitions, that is your problem.
>>
>>
>> Because all simulating halt deciders are deciders they are only
>> accountable for computing the mapping from their input finite strings
>> to an accept or reject state on the basis of whether or not their
>> correctly simulated input could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>> ⟨Ĥ⟩.qn.
>
> And if you are working on the Halting Problem of Computation Theory, BY
> DEFINITION, the meaning of 'correcty simulted' is simulation by a REAL
> UTM which BY DEFINITION exactly matches the behavior of Computation that
> it is representation of, which for <H^> <H^> is H^ applied to <H^>
>

If an infinite number is steps is not enough steps for the correct
simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then the
input to embedded_H meets the Linz definition of a sequence of
configurations that never halts.

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

If your dog is biting your leg and everyone disagrees that your dog is
biting your leg then everyone is gaslighting you and your dog is biting
your leg. https://en.wikipedia.org/wiki/Gaslighting

--
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 V62 [ Linz Proof ]

<hU0MJ.10309$r6p7.7703@fx41.iad>

 copy mid

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

 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!fx41.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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 146
Message-ID: <hU0MJ.10309$r6p7.7703@fx41.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: Sun, 6 Feb 2022 23:05:33 -0500
X-Received-Bytes: 7334
 by: Richard Damon - Mon, 7 Feb 2022 04:05 UTC

On 2/6/22 10:04 PM, olcott wrote:
> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>
>> On 2/6/22 3:53 PM, olcott wrote:
>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>
>>>>>>> H determines [halting] on the basis of matching infinite behavior
>>>>>>> patterns.
>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>> simulation and
>>>>>>> transitions to its final reject state. Otherwise H transitions to
>>>>>>> its
>>>>>>> accept state when its simulation ends.
>>>>>>>
>>>>>> This is incomplete because it does not cover the case where the
>>>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>>>
>>>>>
>>>>> It covers the case that had previously been considered to be proof
>>>>> that the halting problem is undecidable. That is all that I need to
>>>>> refute these proofs.
>>>>>
>>>>>> You need to prove a theorem: There is a finite set of patterns such
>>>>>> that every Turing machine either halts or matches one of these
>>>>>> patterns.
>>>>>>
>>>>>> But I feel sure that theorem is not true.
>>>>>
>>>>> To solve the halting problem my program must be all knowing. To
>>>>> refute the proofs I merely need to show that their counter-example
>>>>> can be proved to never halt.
>>>>>
>>>>
>>>> And you just ignore the fact that if H applied to <H^> <H^> goes to
>>>> H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts, and
>>>> since H, to be an accurate Halt Decider, must only go to H,Qn if the
>>>> machine its input represents will never halt. They you also don't
>>>> seem to understand that the computaton that <H^> <H^> represents IS
>>>> H^ applied to <H^>. So, H was just wrong.
>>>>
>>>> So, you haven't actually proved the thing you claim youhave, but
>>>> only that you have amassed an amazing pile of unsound logic based on
>>>> wrong definitions that have hoodwinked yourself into thinking you
>>>> have shown something useful.
>>>>
>>>> You are so good at doing this that you have gaslighted yourself so
>>>> you can't actually understand what actual Truth is.
>>>>
>>>
>>> You simply do know know enough computer science to understand that
>>> you are wrong and never will because you believe that you are right.
>>>
>>
>> And you clearly don't know enough Computation Theory to talk about it.
>>
>> Since the is a Theorm in Computation Theory, using Computation Theory
>> Deffinitions, that is your problem.
>>>
>>>
>>> Because all simulating halt deciders are deciders they are only
>>> accountable for computing the mapping from their input finite strings
>>> to an accept or reject state on the basis of whether or not their
>>> correctly simulated input could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩
>>> ⊢* ⟨Ĥ⟩.qn.
>>
>> And if you are working on the Halting Problem of Computation Theory,
>> BY DEFINITION, the meaning of 'correcty simulted' is simulation by a
>> REAL UTM which BY DEFINITION exactly matches the behavior of
>> Computation that it is representation of, which for <H^> <H^> is H^
>> applied to <H^>
>>
>
> If an infinite number is steps is not enough steps for the correct
> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then the
> input to embedded_H meets the Linz definition of a sequence of
> configurations that never halts.

WRONG.

If embedded_H DOES an infinite number of steps and doesn't reach a final
state, then it shows its input never halts.

If you now change H/embedded_H to abort and answer, then it would be
correct about that old input, but the problem is that this H is no
longer the origianl H, so the H^ this new H must answer is now
different, so you proof doesn't apply to it.

So, H0 that doesn't abort can show that H0^ <H^0> is non-halting, but
doesn't abort to give that answer.

Change to H1 that does abort, and H1 is correct that H0^ <H0^> doesn't
halt, but that isn't the H^ that it needs to correctly decide on to be
the counter to Linz.

H1 needs to decide on H1^ <H1^> and you have done NOTHING to show if
this halts.

Yes, no matter how long you make this Hn simulate, it will never reach
the point that it will see the ending state for Hn^, (and every variant
of Hm creates a DIFFERENT Hn), but since all these Hn do abort their
simulation, they are NOT the required test of non-halting, that is
reserved for the actual running of the computation, or the simulation by
a REAL UTM.

Since we have stipulated, that Hn <Hn^> <Hn^> will at some point abort
its simulation and go to Hn.Qn (except for n=0, the original), we can
also show that every one of the Hn^ <Hn^> will go to Hn^.Qn also when
its copy of Hn goes to Hn.Qn, and Hn^ will then Halt.

Thus ALL Hn^ <Hn^> will halt, execpt for H0^, since they DO reach a
final state when looked at by the actual definition, and thus all Hn
have failed.

H0 for not giving any answer.
Hn for giving the wrong answer.

You either are testing Hn with the wrong input (H0^ instead of Hn^) or
you are just lying about your result.

FAIL.

>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> If your dog is biting your leg and everyone disagrees that your dog is
> biting your leg then everyone is gaslighting you and your dog is biting
> your leg.                    https://en.wikipedia.org/wiki/Gaslighting
>
>

And if you just think it is a dog, but it is actually a Tiger, then your
thinking it is a dog doesn't change the fact that it is a Tiger biting you.

YOU are the one looking at the wrong thing.

H needs to be tested with the H^ that is built from it, and the Halt
test needs to be done by the definition, which is the actual machine or
a REAL UTM, which isn't your H that aborts its simulation and goes to
H.Qn, BY DEFINITION.

FAIL.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

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

 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: Sun, 06 Feb 2022 22:30:14 -0600
Date: Sun, 6 Feb 2022 22:30:13 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <hU0MJ.10309$r6p7.7703@fx41.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 106
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ipWqP+vNQNsmXKnBKBFfLqdQc4RlOEbiJW3qT7yVWwfCZ078j5i3Sv2L62k8WHh3L3L61PQWdGU4WVB!QtyCXSrqR94xjQuTjiOZexDaoPuhY3J1K0WDq0u1XlfhFSOwbeBBnWm4jcHFkPdvoPB0S8La3qEw
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: 6252
 by: olcott - Mon, 7 Feb 2022 04:30 UTC

On 2/6/2022 10:05 PM, Richard Damon wrote:
>
> On 2/6/22 10:04 PM, olcott wrote:
>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>
>>> On 2/6/22 3:53 PM, olcott wrote:
>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>
>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>> behavior patterns.
>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>> simulation and
>>>>>>>> transitions to its final reject state. Otherwise H transitions
>>>>>>>> to its
>>>>>>>> accept state when its simulation ends.
>>>>>>>>
>>>>>>> This is incomplete because it does not cover the case where the
>>>>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>>>>
>>>>>>
>>>>>> It covers the case that had previously been considered to be proof
>>>>>> that the halting problem is undecidable. That is all that I need
>>>>>> to refute these proofs.
>>>>>>
>>>>>>> You need to prove a theorem: There is a finite set of patterns such
>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>> patterns.
>>>>>>>
>>>>>>> But I feel sure that theorem is not true.
>>>>>>
>>>>>> To solve the halting problem my program must be all knowing. To
>>>>>> refute the proofs I merely need to show that their counter-example
>>>>>> can be proved to never halt.
>>>>>>
>>>>>
>>>>> And you just ignore the fact that if H applied to <H^> <H^> goes to
>>>>> H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts, and
>>>>> since H, to be an accurate Halt Decider, must only go to H,Qn if
>>>>> the machine its input represents will never halt. They you also
>>>>> don't seem to understand that the computaton that <H^> <H^>
>>>>> represents IS H^ applied to <H^>. So, H was just wrong.
>>>>>
>>>>> So, you haven't actually proved the thing you claim youhave, but
>>>>> only that you have amassed an amazing pile of unsound logic based
>>>>> on wrong definitions that have hoodwinked yourself into thinking
>>>>> you have shown something useful.
>>>>>
>>>>> You are so good at doing this that you have gaslighted yourself so
>>>>> you can't actually understand what actual Truth is.
>>>>>
>>>>
>>>> You simply do know know enough computer science to understand that
>>>> you are wrong and never will because you believe that you are right.
>>>>
>>>
>>> And you clearly don't know enough Computation Theory to talk about it.
>>>
>>> Since the is a Theorm in Computation Theory, using Computation Theory
>>> Deffinitions, that is your problem.
>>>>
>>>>
>>>> Because all simulating halt deciders are deciders they are only
>>>> accountable for computing the mapping from their input finite
>>>> strings to an accept or reject state on the basis of whether or not
>>>> their correctly simulated input could ever reach its final state:
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>
>>> And if you are working on the Halting Problem of Computation Theory,
>>> BY DEFINITION, the meaning of 'correcty simulted' is simulation by a
>>> REAL UTM which BY DEFINITION exactly matches the behavior of
>>> Computation that it is representation of, which for <H^> <H^> is H^
>>> applied to <H^>
>>>
>>
>> If an infinite number is steps is not enough steps for the correct
>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then the
>> input to embedded_H meets the Linz definition of a sequence of
>> configurations that never halts.
>
> WRONG.
>
> If embedded_H DOES an infinite number of steps and doesn't reach a final
> state, then it shows its input never halts.
When embedded_H matches this infinite pattern in the same three iterations:

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will never
reach ⟨Ĥ⟩.qn in any number of steps, which proves that this input cannot
possibly meet the Linz definition of halting:

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

--
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 V62 [ Linz Proof ]

<AF7MJ.13063$ZmJ7.6019@fx06.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx06.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 114
Message-ID: <AF7MJ.13063$ZmJ7.6019@fx06.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 7 Feb 2022 06:47:44 -0500
X-Received-Bytes: 6523
 by: Richard Damon - Mon, 7 Feb 2022 11:47 UTC

On 2/6/22 11:30 PM, olcott wrote:
> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>
>> On 2/6/22 10:04 PM, olcott wrote:
>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>
>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>
>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>> behavior patterns.
>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>> simulation and
>>>>>>>>> transitions to its final reject state. Otherwise H transitions
>>>>>>>>> to its
>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>
>>>>>>>> This is incomplete because it does not cover the case where the
>>>>>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>>>>>
>>>>>>>
>>>>>>> It covers the case that had previously been considered to be
>>>>>>> proof that the halting problem is undecidable. That is all that I
>>>>>>> need to refute these proofs.
>>>>>>>
>>>>>>>> You need to prove a theorem: There is a finite set of patterns such
>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>> patterns.
>>>>>>>>
>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>
>>>>>>> To solve the halting problem my program must be all knowing. To
>>>>>>> refute the proofs I merely need to show that their
>>>>>>> counter-example can be proved to never halt.
>>>>>>>
>>>>>>
>>>>>> And you just ignore the fact that if H applied to <H^> <H^> goes
>>>>>> to H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts,
>>>>>> and since H, to be an accurate Halt Decider, must only go to H,Qn
>>>>>> if the machine its input represents will never halt. They you also
>>>>>> don't seem to understand that the computaton that <H^> <H^>
>>>>>> represents IS H^ applied to <H^>. So, H was just wrong.
>>>>>>
>>>>>> So, you haven't actually proved the thing you claim youhave, but
>>>>>> only that you have amassed an amazing pile of unsound logic based
>>>>>> on wrong definitions that have hoodwinked yourself into thinking
>>>>>> you have shown something useful.
>>>>>>
>>>>>> You are so good at doing this that you have gaslighted yourself so
>>>>>> you can't actually understand what actual Truth is.
>>>>>>
>>>>>
>>>>> You simply do know know enough computer science to understand that
>>>>> you are wrong and never will because you believe that you are right.
>>>>>
>>>>
>>>> And you clearly don't know enough Computation Theory to talk about it.
>>>>
>>>> Since the is a Theorm in Computation Theory, using Computation
>>>> Theory Deffinitions, that is your problem.
>>>>>
>>>>>
>>>>> Because all simulating halt deciders are deciders they are only
>>>>> accountable for computing the mapping from their input finite
>>>>> strings to an accept or reject state on the basis of whether or not
>>>>> their correctly simulated input could ever reach its final state:
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>
>>>> And if you are working on the Halting Problem of Computation Theory,
>>>> BY DEFINITION, the meaning of 'correcty simulted' is simulation by a
>>>> REAL UTM which BY DEFINITION exactly matches the behavior of
>>>> Computation that it is representation of, which for <H^> <H^> is H^
>>>> applied to <H^>
>>>>
>>>
>>> If an infinite number is steps is not enough steps for the correct
>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then the
>>> input to embedded_H meets the Linz definition of a sequence of
>>> configurations that never halts.
>>
>> WRONG.
>>
>> If embedded_H DOES an infinite number of steps and doesn't reach a
>> final state, then it shows its input never halts.
> When embedded_H matches this infinite pattern in the same three iterations:
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will never
> reach ⟨Ĥ⟩.qn in any number of steps, which proves that this input cannot
> possibly meet the Linz definition of halting:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>

OK, so the only computatiopn that you show that does not halt is H, so H
can not be a decider.

Note, the Linz definition says **THE TURING MACHINE** so that is what
you need to look at. That a simulator that aborts its processing doesn't
find the end of the processing doesn't prove anything.

After all, an equivalent definition would be a Highway that ends is a
highway that reaches its terminal point, and just because you get off
the highway before its final end doesn't mean the highway has no end.

FAIL.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>

 copy mid

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

 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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 07 Feb 2022 08:59:35 -0600
Date: Mon, 7 Feb 2022 08:59:28 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <AF7MJ.13063$ZmJ7.6019@fx06.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
Lines: 120
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5PqigZRKXrO3E9bVxdM+Jz4JRSllke6Coiyhk5u3r7jCICdPB0iiXbwCXxXhRx3lWXNRGmye8NZu6Vh!IGdsQ5fw1Ne7dqkuck7BKt+c95zP35Cuc6RcAyN1YqrF3KDGSPzhuxg6Xl3S8uu+SaAEDS6i+QIE
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: 6958
 by: olcott - Mon, 7 Feb 2022 14:59 UTC

On 2/7/2022 5:47 AM, Richard Damon wrote:
> On 2/6/22 11:30 PM, olcott wrote:
>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>
>>> On 2/6/22 10:04 PM, olcott wrote:
>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>
>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>> behavior patterns.
>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>> simulation and
>>>>>>>>>> transitions to its final reject state. Otherwise H transitions
>>>>>>>>>> to its
>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>
>>>>>>>>> This is incomplete because it does not cover the case where the
>>>>>>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>>>>>>
>>>>>>>>
>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>> proof that the halting problem is undecidable. That is all that
>>>>>>>> I need to refute these proofs.
>>>>>>>>
>>>>>>>>> You need to prove a theorem: There is a finite set of patterns
>>>>>>>>> such
>>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>>> patterns.
>>>>>>>>>
>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>
>>>>>>>> To solve the halting problem my program must be all knowing. To
>>>>>>>> refute the proofs I merely need to show that their
>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>
>>>>>>>
>>>>>>> And you just ignore the fact that if H applied to <H^> <H^> goes
>>>>>>> to H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts,
>>>>>>> and since H, to be an accurate Halt Decider, must only go to H,Qn
>>>>>>> if the machine its input represents will never halt. They you
>>>>>>> also don't seem to understand that the computaton that <H^> <H^>
>>>>>>> represents IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>
>>>>>>> So, you haven't actually proved the thing you claim youhave, but
>>>>>>> only that you have amassed an amazing pile of unsound logic based
>>>>>>> on wrong definitions that have hoodwinked yourself into thinking
>>>>>>> you have shown something useful.
>>>>>>>
>>>>>>> You are so good at doing this that you have gaslighted yourself
>>>>>>> so you can't actually understand what actual Truth is.
>>>>>>>
>>>>>>
>>>>>> You simply do know know enough computer science to understand that
>>>>>> you are wrong and never will because you believe that you are right.
>>>>>>
>>>>>
>>>>> And you clearly don't know enough Computation Theory to talk about it.
>>>>>
>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>> Theory Deffinitions, that is your problem.
>>>>>>
>>>>>>
>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>> accountable for computing the mapping from their input finite
>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>> not their correctly simulated input could ever reach its final
>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>
>>>>> And if you are working on the Halting Problem of Computation
>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches the
>>>>> behavior of Computation that it is representation of, which for
>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>
>>>>
>>>> If an infinite number is steps is not enough steps for the correct
>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then the
>>>> input to embedded_H meets the Linz definition of a sequence of
>>>> configurations that never halts.
>>>
>>> WRONG.
>>>
>>> If embedded_H DOES an infinite number of steps and doesn't reach a
>>> final state, then it shows its input never halts.
>> When embedded_H matches this infinite pattern in the same three
>> iterations:
>>
>> Then these steps would keep repeating:
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>> ⟨Ĥ5⟩...
>>
>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>> input cannot possibly meet the Linz definition of halting:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>
> OK, so the only computatiopn that you show that does not halt is H, so H
> can not be a decider.

In the above example embedded_H simulates three iterations of nested
simulation to match the infinitely nested simulation pattern.
In reality it needs less than this to match this pattern.

--
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 V62 [ Linz Proof ]

<9biMJ.10134$Wdl5.2747@fx44.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 133
Message-ID: <9biMJ.10134$Wdl5.2747@fx44.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: Mon, 7 Feb 2022 18:46:14 -0500
X-Received-Bytes: 7316
X-Original-Bytes: 7183
 by: Richard Damon - Mon, 7 Feb 2022 23:46 UTC

On 2/7/22 9:59 AM, olcott wrote:
> On 2/7/2022 5:47 AM, Richard Damon wrote:
>> On 2/6/22 11:30 PM, olcott wrote:
>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>
>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>> behavior patterns.
>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>> simulation and
>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>> transitions to its
>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>
>>>>>>>>>> This is incomplete because it does not cover the case where the
>>>>>>>>>> machine neither halts nor matches an "infinite behavior pattern".
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>>> proof that the halting problem is undecidable. That is all that
>>>>>>>>> I need to refute these proofs.
>>>>>>>>>
>>>>>>>>>> You need to prove a theorem: There is a finite set of patterns
>>>>>>>>>> such
>>>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>>>> patterns.
>>>>>>>>>>
>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>
>>>>>>>>> To solve the halting problem my program must be all knowing. To
>>>>>>>>> refute the proofs I merely need to show that their
>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^> goes
>>>>>>>> to H.Qn, then by construction H^ <H^> goes to H^.Qn, and halts,
>>>>>>>> and since H, to be an accurate Halt Decider, must only go to
>>>>>>>> H,Qn if the machine its input represents will never halt. They
>>>>>>>> you also don't seem to understand that the computaton that <H^>
>>>>>>>> <H^> represents IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>>
>>>>>>>> So, you haven't actually proved the thing you claim youhave, but
>>>>>>>> only that you have amassed an amazing pile of unsound logic
>>>>>>>> based on wrong definitions that have hoodwinked yourself into
>>>>>>>> thinking you have shown something useful.
>>>>>>>>
>>>>>>>> You are so good at doing this that you have gaslighted yourself
>>>>>>>> so you can't actually understand what actual Truth is.
>>>>>>>>
>>>>>>>
>>>>>>> You simply do know know enough computer science to understand
>>>>>>> that you are wrong and never will because you believe that you
>>>>>>> are right.
>>>>>>>
>>>>>>
>>>>>> And you clearly don't know enough Computation Theory to talk about
>>>>>> it.
>>>>>>
>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>
>>>>>>>
>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>> accountable for computing the mapping from their input finite
>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>> not their correctly simulated input could ever reach its final
>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>
>>>>>> And if you are working on the Halting Problem of Computation
>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches the
>>>>>> behavior of Computation that it is representation of, which for
>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>
>>>>>
>>>>> If an infinite number is steps is not enough steps for the correct
>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then
>>>>> the input to embedded_H meets the Linz definition of a sequence of
>>>>> configurations that never halts.
>>>>
>>>> WRONG.
>>>>
>>>> If embedded_H DOES an infinite number of steps and doesn't reach a
>>>> final state, then it shows its input never halts.
>>> When embedded_H matches this infinite pattern in the same three
>>> iterations:
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>> ⟨Ĥ5⟩...
>>>
>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>> input cannot possibly meet the Linz definition of halting:
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>
>> OK, so the only computatiopn that you show that does not halt is H, so
>> H can not be a decider.
>
> In the above example embedded_H simulates three iterations of nested
> simulation to match the infinitely nested simulation pattern.
> In reality it needs less than this to match this pattern.
>
>

And if it doesn't do an infinite number, the H^ that is using it will
Halt, and thus Halting is the right answer, since that shows that H^
applied to <H^>, which is tne meaning of <H^> <H^>, and thus the
REQUIRMENT on H to be correct would be to go to H.Qy, not H.Qn, so
H/embedded_H is wrong.

IF H/embedded_H does continue so that pattern actually IS infinite, they
don't give the answer.

Remember, if 1 H aborts its simulation of <H^> <H^>, then ALL copies of
H/embedded_H will do so, so the pattern is NOT an infinite loop, but a
finilte loop whose number of cycles is determined by the number of
cycles that H allows to happen before it aborts.

FAIL.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

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

 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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 07 Feb 2022 19:08:11 -0600
Date: Mon, 7 Feb 2022 19:08:03 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <9biMJ.10134$Wdl5.2747@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 134
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EU5A23pwGYg6mDlzk5k1M0h8bSrdltIiFujZC0y85t7xwD7QIx6UAYvQXbZyvr6gqdRO8GszcZhBPFQ!TyF+LGij6o4RwI4jTzd1bc65LBs0a0rdLEqG36edzIWKS3CEhkwc7N+vwwJHisG4O6S/XEbCTpvN
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: 7693
 by: olcott - Tue, 8 Feb 2022 01:08 UTC

On 2/7/2022 5:46 PM, Richard Damon wrote:
> On 2/7/22 9:59 AM, olcott wrote:
>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>> On 2/6/22 11:30 PM, olcott wrote:
>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>>> simulation and
>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>> transitions to its
>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>
>>>>>>>>>>> This is incomplete because it does not cover the case where the
>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>> pattern".
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>>>> proof that the halting problem is undecidable. That is all
>>>>>>>>>> that I need to refute these proofs.
>>>>>>>>>>
>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>> patterns such
>>>>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>>>>> patterns.
>>>>>>>>>>>
>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>
>>>>>>>>>> To solve the halting problem my program must be all knowing.
>>>>>>>>>> To refute the proofs I merely need to show that their
>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn, and
>>>>>>>>> halts, and since H, to be an accurate Halt Decider, must only
>>>>>>>>> go to H,Qn if the machine its input represents will never halt.
>>>>>>>>> They you also don't seem to understand that the computaton that
>>>>>>>>> <H^> <H^> represents IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>>>
>>>>>>>>> So, you haven't actually proved the thing you claim youhave,
>>>>>>>>> but only that you have amassed an amazing pile of unsound logic
>>>>>>>>> based on wrong definitions that have hoodwinked yourself into
>>>>>>>>> thinking you have shown something useful.
>>>>>>>>>
>>>>>>>>> You are so good at doing this that you have gaslighted yourself
>>>>>>>>> so you can't actually understand what actual Truth is.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You simply do know know enough computer science to understand
>>>>>>>> that you are wrong and never will because you believe that you
>>>>>>>> are right.
>>>>>>>>
>>>>>>>
>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>> about it.
>>>>>>>
>>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>>
>>>>>>>>
>>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>>> accountable for computing the mapping from their input finite
>>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>>> not their correctly simulated input could ever reach its final
>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>
>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches the
>>>>>>> behavior of Computation that it is representation of, which for
>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>
>>>>>>
>>>>>> If an infinite number is steps is not enough steps for the correct
>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to ⟨Ĥ⟩.qn then
>>>>>> the input to embedded_H meets the Linz definition of a sequence of
>>>>>> configurations that never halts.
>>>>>
>>>>> WRONG.
>>>>>
>>>>> If embedded_H DOES an infinite number of steps and doesn't reach a
>>>>> final state, then it shows its input never halts.
>>>> When embedded_H matches this infinite pattern in the same three
>>>> iterations:
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>> ⟨Ĥ5⟩...
>>>>
>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>>> input cannot possibly meet the Linz definition of halting:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>
>>> OK, so the only computatiopn that you show that does not halt is H,
>>> so H can not be a decider.
>>
>> In the above example embedded_H simulates three iterations of nested
>> simulation to match the infinitely nested simulation pattern.
>> In reality it needs less than this to match this pattern.
>>
>>
>
> And if it doesn't do an infinite number, the H^ that is using it will
> Halt,

embedded_H only examines the actual behavior of its inputs as if its was
a guard assigned to watch the front. If someone comes in the back door
(non-inputs) embedded_H is not even allowed to pay attention.

--
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 V62 [ Linz Proof ]

<HEjMJ.6348$979a.2933@fx14.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx14.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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 147
Message-ID: <HEjMJ.6348$979a.2933@fx14.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: Mon, 7 Feb 2022 20:26:00 -0500
X-Received-Bytes: 7801
X-Original-Bytes: 7668
 by: Richard Damon - Tue, 8 Feb 2022 01:26 UTC

On 2/7/22 8:08 PM, olcott wrote:
> On 2/7/2022 5:46 PM, Richard Damon wrote:
>> On 2/7/22 9:59 AM, olcott wrote:
>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>
>>>>>>>>>>>> This is incomplete because it does not cover the case where the
>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>> pattern".
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>>>>> proof that the halting problem is undecidable. That is all
>>>>>>>>>>> that I need to refute these proofs.
>>>>>>>>>>>
>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>> patterns such
>>>>>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>>>>>> patterns.
>>>>>>>>>>>>
>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>
>>>>>>>>>>> To solve the halting problem my program must be all knowing.
>>>>>>>>>>> To refute the proofs I merely need to show that their
>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>> halts, and since H, to be an accurate Halt Decider, must only
>>>>>>>>>> go to H,Qn if the machine its input represents will never
>>>>>>>>>> halt. They you also don't seem to understand that the
>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied to <H^>.
>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>
>>>>>>>>>> So, you haven't actually proved the thing you claim youhave,
>>>>>>>>>> but only that you have amassed an amazing pile of unsound
>>>>>>>>>> logic based on wrong definitions that have hoodwinked yourself
>>>>>>>>>> into thinking you have shown something useful.
>>>>>>>>>>
>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>> yourself so you can't actually understand what actual Truth is.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You simply do know know enough computer science to understand
>>>>>>>>> that you are wrong and never will because you believe that you
>>>>>>>>> are right.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>> about it.
>>>>>>>>
>>>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>>>> accountable for computing the mapping from their input finite
>>>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>>>> not their correctly simulated input could ever reach its final
>>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>
>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches the
>>>>>>>> behavior of Computation that it is representation of, which for
>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>
>>>>>>>
>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition of
>>>>>>> a sequence of configurations that never halts.
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>> If embedded_H DOES an infinite number of steps and doesn't reach a
>>>>>> final state, then it shows its input never halts.
>>>>> When embedded_H matches this infinite pattern in the same three
>>>>> iterations:
>>>>>
>>>>> Then these steps would keep repeating:
>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
>>>>> ⟨Ĥ3⟩
>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
>>>>> ⟨Ĥ4⟩
>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>>> ⟨Ĥ5⟩...
>>>>>
>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>>>> input cannot possibly meet the Linz definition of halting:
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>
>>>> OK, so the only computatiopn that you show that does not halt is H,
>>>> so H can not be a decider.
>>>
>>> In the above example embedded_H simulates three iterations of nested
>>> simulation to match the infinitely nested simulation pattern.
>>> In reality it needs less than this to match this pattern.
>>>
>>>
>>
>> And if it doesn't do an infinite number, the H^ that is using it will
>> Halt,
>
> embedded_H only examines the actual behavior of its inputs as if its was
> a guard assigned to watch the front. If someone comes in the back door
> (non-inputs) embedded_H is not even allowed to pay attention.
>

If the 'actual behavior' of the input <H^> <H^> is not the behavior of
H^ applied to <H^> you are lying about doing the Halting Problem.

That is a DEFINITION.

Remember H appied to wM w is to go to H.Qy/H.Qn based on the behavior of
M applied to w.

M = H^, wm = <H^>, w = <H^>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 07 Feb 2022 19:52:32 -0600
Date: Mon, 7 Feb 2022 19:52:31 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <HEjMJ.6348$979a.2933@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
Lines: 156
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kwHDhRfBmU2jMRknAC+6aNgxx6taK8dV2EWhlXd1rJqHZTbUD2wc68Z4apFcVSUBD+l3/GhL0IUg0NW!quY8iRjsw4foM3K7VmWOIKaNpfvn0PC/DPMx3sluOzP0u166KZTRRVQdOuxn+m5eCuhROL0LUrTG
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: 8877
 by: olcott - Tue, 8 Feb 2022 01:52 UTC

On 2/7/2022 7:26 PM, Richard Damon wrote:
> On 2/7/22 8:08 PM, olcott wrote:
>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>> On 2/7/22 9:59 AM, olcott wrote:
>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> This is incomplete because it does not cover the case where
>>>>>>>>>>>>> the
>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>>>>>> proof that the halting problem is undecidable. That is all
>>>>>>>>>>>> that I need to refute these proofs.
>>>>>>>>>>>>
>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>
>>>>>>>>>>>> To solve the halting problem my program must be all knowing.
>>>>>>>>>>>> To refute the proofs I merely need to show that their
>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>> halts, and since H, to be an accurate Halt Decider, must only
>>>>>>>>>>> go to H,Qn if the machine its input represents will never
>>>>>>>>>>> halt. They you also don't seem to understand that the
>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied to <H^>.
>>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>>
>>>>>>>>>>> So, you haven't actually proved the thing you claim youhave,
>>>>>>>>>>> but only that you have amassed an amazing pile of unsound
>>>>>>>>>>> logic based on wrong definitions that have hoodwinked
>>>>>>>>>>> yourself into thinking you have shown something useful.
>>>>>>>>>>>
>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>> yourself so you can't actually understand what actual Truth is.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You simply do know know enough computer science to understand
>>>>>>>>>> that you are wrong and never will because you believe that you
>>>>>>>>>> are right.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>>> about it.
>>>>>>>>>
>>>>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>> whether or not their correctly simulated input could ever
>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>
>>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>> the behavior of Computation that it is representation of, which
>>>>>>>>> for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>
>>>>>>>>
>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition of
>>>>>>>> a sequence of configurations that never halts.
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>> If embedded_H DOES an infinite number of steps and doesn't reach
>>>>>>> a final state, then it shows its input never halts.
>>>>>> When embedded_H matches this infinite pattern in the same three
>>>>>> iterations:
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
>>>>>> ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
>>>>>> ⟨Ĥ4⟩
>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>>>> ⟨Ĥ5⟩...
>>>>>>
>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>>>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>>>>> input cannot possibly meet the Linz definition of halting:
>>>>>>
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters a final state. (Linz:1990:234)
>>>>>>
>>>>>
>>>>> OK, so the only computatiopn that you show that does not halt is H,
>>>>> so H can not be a decider.
>>>>
>>>> In the above example embedded_H simulates three iterations of nested
>>>> simulation to match the infinitely nested simulation pattern.
>>>> In reality it needs less than this to match this pattern.
>>>>
>>>>
>>>
>>> And if it doesn't do an infinite number, the H^ that is using it will
>>> Halt,
>>
>> embedded_H only examines the actual behavior of its inputs as if its
>> was a guard assigned to watch the front. If someone comes in the back
>> door (non-inputs) embedded_H is not even allowed to pay attention.
>>
>
> If the 'actual behavior' of the input <H^> <H^> is not the behavior of
> H^ applied to <H^> you are lying about doing the Halting Problem.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<7ckMJ.40194$%uX7.13960@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 185
Message-ID: <7ckMJ.40194$%uX7.13960@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 7 Feb 2022 21:03:47 -0500
X-Received-Bytes: 9870
 by: Richard Damon - Tue, 8 Feb 2022 02:03 UTC

On 2/7/22 8:52 PM, olcott wrote:
> On 2/7/2022 7:26 PM, Richard Damon wrote:
>> On 2/7/22 8:08 PM, olcott wrote:
>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is incomplete because it does not cover the case
>>>>>>>>>>>>>> where the
>>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It covers the case that had previously been considered to
>>>>>>>>>>>>> be proof that the halting problem is undecidable. That is
>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>> that every Turing machine either halts or matches one of
>>>>>>>>>>>>>> these
>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show that
>>>>>>>>>>>>> their counter-example can be proved to never halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn,
>>>>>>>>>>>> and halts, and since H, to be an accurate Halt Decider, must
>>>>>>>>>>>> only go to H,Qn if the machine its input represents will
>>>>>>>>>>>> never halt. They you also don't seem to understand that the
>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied to <H^>.
>>>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> So, you haven't actually proved the thing you claim youhave,
>>>>>>>>>>>> but only that you have amassed an amazing pile of unsound
>>>>>>>>>>>> logic based on wrong definitions that have hoodwinked
>>>>>>>>>>>> yourself into thinking you have shown something useful.
>>>>>>>>>>>>
>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>> yourself so you can't actually understand what actual Truth is.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You simply do know know enough computer science to understand
>>>>>>>>>>> that you are wrong and never will because you believe that
>>>>>>>>>>> you are right.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>>>> about it.
>>>>>>>>>>
>>>>>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>> whether or not their correctly simulated input could ever
>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>
>>>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>>> the behavior of Computation that it is representation of,
>>>>>>>>>> which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition
>>>>>>>>> of a sequence of configurations that never halts.
>>>>>>>>
>>>>>>>> WRONG.
>>>>>>>>
>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't reach
>>>>>>>> a final state, then it shows its input never halts.
>>>>>>> When embedded_H matches this infinite pattern in the same three
>>>>>>> iterations:
>>>>>>>
>>>>>>> Then these steps would keep repeating:
>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>
>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>>>>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>>>>>> input cannot possibly meet the Linz definition of halting:
>>>>>>>
>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>
>>>>>>
>>>>>> OK, so the only computatiopn that you show that does not halt is
>>>>>> H, so H can not be a decider.
>>>>>
>>>>> In the above example embedded_H simulates three iterations of
>>>>> nested simulation to match the infinitely nested simulation pattern.
>>>>> In reality it needs less than this to match this pattern.
>>>>>
>>>>>
>>>>
>>>> And if it doesn't do an infinite number, the H^ that is using it
>>>> will Halt,
>>>
>>> embedded_H only examines the actual behavior of its inputs as if its
>>> was a guard assigned to watch the front. If someone comes in the back
>>> door (non-inputs) embedded_H is not even allowed to pay attention.
>>>
>>
>> If the 'actual behavior' of the input <H^> <H^> is not the behavior of
>> H^ applied to <H^> you are lying about doing the Halting Problem.
>>
>
> If it is true that the simulated input to embedded_H cannot possibly
> ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the universe can
> possibly contradict the fact that the input specifies a non-halting
> sequences of configurations. If God himself said otherwise then God
> himself would be a liar.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<stsv18$6e3$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Date: Mon, 7 Feb 2022 23:28:07 -0600
Organization: A noiseless patient Spider
Lines: 196
Message-ID: <stsv18$6e3$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 8 Feb 2022 05:28:08 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="765fed866a0e39f87ebb9620924d8bfb";
logging-data="6595"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX191Up01rKOCs+0ZiIP6cP22"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:49KLCCpI5VF21DNSCr57Z+VstW8=
In-Reply-To: <7ckMJ.40194$%uX7.13960@fx38.iad>
Content-Language: en-US
 by: olcott - Tue, 8 Feb 2022 05:28 UTC

On 2/7/2022 8:03 PM, Richard Damon wrote:
>
> On 2/7/22 8:52 PM, olcott wrote:
>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>> On 2/7/22 8:08 PM, olcott wrote:
>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts
>>>>>>>>>>>>>>>> its simulation and
>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is incomplete because it does not cover the case
>>>>>>>>>>>>>>> where the
>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It covers the case that had previously been considered to
>>>>>>>>>>>>>> be proof that the halting problem is undecidable. That is
>>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>>> that every Turing machine either halts or matches one of
>>>>>>>>>>>>>>> these
>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show that
>>>>>>>>>>>>>> their counter-example can be proved to never halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn,
>>>>>>>>>>>>> and halts, and since H, to be an accurate Halt Decider,
>>>>>>>>>>>>> must only go to H,Qn if the machine its input represents
>>>>>>>>>>>>> will never halt. They you also don't seem to understand
>>>>>>>>>>>>> that the computaton that <H^> <H^> represents IS H^ applied
>>>>>>>>>>>>> to <H^>. So, H was just wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>> youhave, but only that you have amassed an amazing pile of
>>>>>>>>>>>>> unsound logic based on wrong definitions that have
>>>>>>>>>>>>> hoodwinked yourself into thinking you have shown something
>>>>>>>>>>>>> useful.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>> yourself so you can't actually understand what actual Truth
>>>>>>>>>>>>> is.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>> understand that you are wrong and never will because you
>>>>>>>>>>>> believe that you are right.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>>>>> about it.
>>>>>>>>>>>
>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>>> whether or not their correctly simulated input could ever
>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>
>>>>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>>>> the behavior of Computation that it is representation of,
>>>>>>>>>>> which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition
>>>>>>>>>> of a sequence of configurations that never halts.
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>>>
>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't
>>>>>>>>> reach a final state, then it shows its input never halts.
>>>>>>>> When embedded_H matches this infinite pattern in the same three
>>>>>>>> iterations:
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>
>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>> will never reach ⟨Ĥ⟩.qn in any number of steps, which proves
>>>>>>>> that this input cannot possibly meet the Linz definition of
>>>>>>>> halting:
>>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>
>>>>>>> OK, so the only computatiopn that you show that does not halt is
>>>>>>> H, so H can not be a decider.
>>>>>>
>>>>>> In the above example embedded_H simulates three iterations of
>>>>>> nested simulation to match the infinitely nested simulation pattern.
>>>>>> In reality it needs less than this to match this pattern.
>>>>>>
>>>>>>
>>>>>
>>>>> And if it doesn't do an infinite number, the H^ that is using it
>>>>> will Halt,
>>>>
>>>> embedded_H only examines the actual behavior of its inputs as if its
>>>> was a guard assigned to watch the front. If someone comes in the
>>>> back door (non-inputs) embedded_H is not even allowed to pay attention.
>>>>
>>>
>>> If the 'actual behavior' of the input <H^> <H^> is not the behavior
>>> of H^ applied to <H^> you are lying about doing the Halting Problem.
>>>
>>
>> If it is true that the simulated input to embedded_H cannot possibly
>> ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the universe can
>> possibly contradict the fact that the input specifies a non-halting
>> sequences of configurations. If God himself said otherwise then God
>> himself would be a liar.
>>
>
> Except that if H/embedded_H aborts its simulation and goes to H.Qn, then
> the CORRECT simulation of its input (that done by a REAL UTM) will show
> that it will go to H^.Qn.
>
> All you have proven is that if H doesn't abort, and thus doesn't go to
> H.Qn, and thus fails to be a correct decider, then H^ applied to <H^> is
> non-halting.
>
> You keep on thinking that a simulation that aborts its simulation is a
> 'correct' simulation. By the definition in Computation Theory, this is
> not true. If you think it is, it just proves that you don't understand
> the field.
>
> FAIL.
>
>> If we know that we have a black cat then we know that we have a cat.
>
> Except that if you DON'T have a black cat but think you do then you are
> wrong. If H aborts its simulation, it isn't a UTM and doesn't
> 'correctly' simulate.
>
>>
>> If we know that we have a sequence of configurations that cannot
>> possibly ever reach its final state then we know that we have a
>> non-halting sequence of configurations.
>>
>
> Except that is has been PROVEN that if H -> H.Qn then the pattern WILL
> reach the final state.
>
> The fact that H can't ever reach that state proves just proves that if H
> is a UTM, which don't abort, then H^ will be non-halting, but H is still
> wrong for not answering. If H does abort, then it hasn't proven
> anything, and it has been proven that it is wrong.
>
> FAIL


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<2UsMJ.18969$3jp8.698@fx33.iad>

 copy mid

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

 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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx33.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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <stsv18$6e3$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 210
Message-ID: <2UsMJ.18969$3jp8.698@fx33.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 8 Feb 2022 06:56:47 -0500
X-Received-Bytes: 11178
 by: Richard Damon - Tue, 8 Feb 2022 11:56 UTC

On 2/8/22 12:28 AM, olcott wrote:
> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>
>> On 2/7/22 8:52 PM, olcott wrote:
>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts
>>>>>>>>>>>>>>>>> its simulation and
>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is incomplete because it does not cover the case
>>>>>>>>>>>>>>>> where the
>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It covers the case that had previously been considered to
>>>>>>>>>>>>>>> be proof that the halting problem is undecidable. That is
>>>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>>>> that every Turing machine either halts or matches one of
>>>>>>>>>>>>>>>> these
>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show that
>>>>>>>>>>>>>>> their counter-example can be proved to never halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^>
>>>>>>>>>>>>>> <H^> goes to H.Qn, then by construction H^ <H^> goes to
>>>>>>>>>>>>>> H^.Qn, and halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>> Decider, must only go to H,Qn if the machine its input
>>>>>>>>>>>>>> represents will never halt. They you also don't seem to
>>>>>>>>>>>>>> understand that the computaton that <H^> <H^> represents
>>>>>>>>>>>>>> IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing pile of
>>>>>>>>>>>>>> unsound logic based on wrong definitions that have
>>>>>>>>>>>>>> hoodwinked yourself into thinking you have shown something
>>>>>>>>>>>>>> useful.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>>> yourself so you can't actually understand what actual
>>>>>>>>>>>>>> Truth is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>> understand that you are wrong and never will because you
>>>>>>>>>>>>> believe that you are right.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>>>>>> about it.
>>>>>>>>>>>>
>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>>>> whether or not their correctly simulated input could ever
>>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>
>>>>>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>>>>> the behavior of Computation that it is representation of,
>>>>>>>>>>>> which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition
>>>>>>>>>>> of a sequence of configurations that never halts.
>>>>>>>>>>
>>>>>>>>>> WRONG.
>>>>>>>>>>
>>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't
>>>>>>>>>> reach a final state, then it shows its input never halts.
>>>>>>>>> When embedded_H matches this infinite pattern in the same three
>>>>>>>>> iterations:
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>
>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>> will never reach ⟨Ĥ⟩.qn in any number of steps, which proves
>>>>>>>>> that this input cannot possibly meet the Linz definition of
>>>>>>>>> halting:
>>>>>>>>>
>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>
>>>>>>>> OK, so the only computatiopn that you show that does not halt is
>>>>>>>> H, so H can not be a decider.
>>>>>>>
>>>>>>> In the above example embedded_H simulates three iterations of
>>>>>>> nested simulation to match the infinitely nested simulation pattern.
>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And if it doesn't do an infinite number, the H^ that is using it
>>>>>> will Halt,
>>>>>
>>>>> embedded_H only examines the actual behavior of its inputs as if
>>>>> its was a guard assigned to watch the front. If someone comes in
>>>>> the back door (non-inputs) embedded_H is not even allowed to pay
>>>>> attention.
>>>>>
>>>>
>>>> If the 'actual behavior' of the input <H^> <H^> is not the behavior
>>>> of H^ applied to <H^> you are lying about doing the Halting Problem.
>>>>
>>>
>>> If it is true that the simulated input to embedded_H cannot possibly
>>> ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the universe
>>> can possibly contradict the fact that the input specifies a
>>> non-halting sequences of configurations. If God himself said
>>> otherwise then God himself would be a liar.
>>>
>>
>> Except that if H/embedded_H aborts its simulation and goes to H.Qn,
>> then the CORRECT simulation of its input (that done by a REAL UTM)
>> will show that it will go to H^.Qn.
>>
>> All you have proven is that if H doesn't abort, and thus doesn't go to
>> H.Qn, and thus fails to be a correct decider, then H^ applied to <H^>
>> is non-halting.
>>
>> You keep on thinking that a simulation that aborts its simulation is a
>> 'correct' simulation. By the definition in Computation Theory, this is
>> not true. If you think it is, it just proves that you don't understand
>> the field.
>>
>> FAIL.
>>
>>> If we know that we have a black cat then we know that we have a cat.
>>
>> Except that if you DON'T have a black cat but think you do then you
>> are wrong. If H aborts its simulation, it isn't a UTM and doesn't
>> 'correctly' simulate.
>>
>>>
>>> If we know that we have a sequence of configurations that cannot
>>> possibly ever reach its final state then we know that we have a
>>> non-halting sequence of configurations.
>>>
>>
>> Except that is has been PROVEN that if H -> H.Qn then the pattern WILL
>> reach the final state.
>>
>> The fact that H can't ever reach that state proves just proves that if
>> H is a UTM, which don't abort, then H^ will be non-halting, but H is
>> still wrong for not answering. If H does abort, then it hasn't proven
>> anything, and it has been proven that it is wrong.
>>
>> FAIL
>
> You are either not bright enough to get this or dishonest.
> I don't care which, I need to up my game to computer scientists.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<stu2kf$4hg$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Followup-To: comp.theory
Date: Tue, 8 Feb 2022 09:35:41 -0600
Organization: A noiseless patient Spider
Lines: 228
Message-ID: <stu2kf$4hg$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 8 Feb 2022 15:35:43 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="765fed866a0e39f87ebb9620924d8bfb";
logging-data="4656"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/11qUskxyqEADAP7NWXBhA"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:7v9dtPHKtJ3jxQYIrnO/ISef8bc=
In-Reply-To: <2UsMJ.18969$3jp8.698@fx33.iad>
Content-Language: en-US
 by: olcott - Tue, 8 Feb 2022 15:35 UTC

On 2/8/2022 5:56 AM, Richard Damon wrote:
> On 2/8/22 12:28 AM, olcott wrote:
>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>
>>> On 2/7/22 8:52 PM, olcott wrote:
>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts
>>>>>>>>>>>>>>>>>> its simulation and
>>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the case
>>>>>>>>>>>>>>>>> where the
>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It covers the case that had previously been considered
>>>>>>>>>>>>>>>> to be proof that the halting problem is undecidable.
>>>>>>>>>>>>>>>> That is all that I need to refute these proofs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>>>>> that every Turing machine either halts or matches one
>>>>>>>>>>>>>>>>> of these
>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show that
>>>>>>>>>>>>>>>> their counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^>
>>>>>>>>>>>>>>> <H^> goes to H.Qn, then by construction H^ <H^> goes to
>>>>>>>>>>>>>>> H^.Qn, and halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>>> Decider, must only go to H,Qn if the machine its input
>>>>>>>>>>>>>>> represents will never halt. They you also don't seem to
>>>>>>>>>>>>>>> understand that the computaton that <H^> <H^> represents
>>>>>>>>>>>>>>> IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing pile
>>>>>>>>>>>>>>> of unsound logic based on wrong definitions that have
>>>>>>>>>>>>>>> hoodwinked yourself into thinking you have shown
>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>>>> yourself so you can't actually understand what actual
>>>>>>>>>>>>>>> Truth is.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>> understand that you are wrong and never will because you
>>>>>>>>>>>>>> believe that you are right.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you clearly don't know enough Computation Theory to
>>>>>>>>>>>>> talk about it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>>>> only accountable for computing the mapping from their
>>>>>>>>>>>>>> input finite strings to an accept or reject state on the
>>>>>>>>>>>>>> basis of whether or not their correctly simulated input
>>>>>>>>>>>>>> could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>> simulted' is simulation by a REAL UTM which BY DEFINITION
>>>>>>>>>>>>> exactly matches the behavior of Computation that it is
>>>>>>>>>>>>> representation of, which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz
>>>>>>>>>>>> definition of a sequence of configurations that never halts.
>>>>>>>>>>>
>>>>>>>>>>> WRONG.
>>>>>>>>>>>
>>>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't
>>>>>>>>>>> reach a final state, then it shows its input never halts.
>>>>>>>>>> When embedded_H matches this infinite pattern in the same
>>>>>>>>>> three iterations:
>>>>>>>>>>
>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>
>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>> will never reach ⟨Ĥ⟩.qn in any number of steps, which proves
>>>>>>>>>> that this input cannot possibly meet the Linz definition of
>>>>>>>>>> halting:
>>>>>>>>>>
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> OK, so the only computatiopn that you show that does not halt
>>>>>>>>> is H, so H can not be a decider.
>>>>>>>>
>>>>>>>> In the above example embedded_H simulates three iterations of
>>>>>>>> nested simulation to match the infinitely nested simulation
>>>>>>>> pattern.
>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And if it doesn't do an infinite number, the H^ that is using it
>>>>>>> will Halt,
>>>>>>
>>>>>> embedded_H only examines the actual behavior of its inputs as if
>>>>>> its was a guard assigned to watch the front. If someone comes in
>>>>>> the back door (non-inputs) embedded_H is not even allowed to pay
>>>>>> attention.
>>>>>>
>>>>>
>>>>> If the 'actual behavior' of the input <H^> <H^> is not the behavior
>>>>> of H^ applied to <H^> you are lying about doing the Halting Problem.
>>>>>
>>>>
>>>> If it is true that the simulated input to embedded_H cannot possibly
>>>> ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the universe
>>>> can possibly contradict the fact that the input specifies a
>>>> non-halting sequences of configurations. If God himself said
>>>> otherwise then God himself would be a liar.
>>>>
>>>
>>> Except that if H/embedded_H aborts its simulation and goes to H.Qn,
>>> then the CORRECT simulation of its input (that done by a REAL UTM)
>>> will show that it will go to H^.Qn.
>>>
>>> All you have proven is that if H doesn't abort, and thus doesn't go
>>> to H.Qn, and thus fails to be a correct decider, then H^ applied to
>>> <H^> is non-halting.
>>>
>>> You keep on thinking that a simulation that aborts its simulation is
>>> a 'correct' simulation. By the definition in Computation Theory, this
>>> is not true. If you think it is, it just proves that you don't
>>> understand the field.
>>>
>>> FAIL.
>>>
>>>> If we know that we have a black cat then we know that we have a cat.
>>>
>>> Except that if you DON'T have a black cat but think you do then you
>>> are wrong. If H aborts its simulation, it isn't a UTM and doesn't
>>> 'correctly' simulate.
>>>
>>>>
>>>> If we know that we have a sequence of configurations that cannot
>>>> possibly ever reach its final state then we know that we have a
>>>> non-halting sequence of configurations.
>>>>
>>>
>>> Except that is has been PROVEN that if H -> H.Qn then the pattern
>>> WILL reach the final state.
>>>
>>> The fact that H can't ever reach that state proves just proves that
>>> if H is a UTM, which don't abort, then H^ will be non-halting, but H
>>> is still wrong for not answering. If H does abort, then it hasn't
>>> proven anything, and it has been proven that it is wrong.
>>>
>>> FAIL
>>
>> You are either not bright enough to get this or dishonest.
>> I don't care which, I need to up my game to computer scientists.
>>
>
> So, can't refute what I say so you go to arguing by insults, classic
> Olcott logical fallicy.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]( application to AI research )

<TJSdna7Ju4PtL5__nZ2dnUU7-aPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.ai.philosophy comp.theory sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 08 Feb 2022 12:12:00 -0600
Date: Tue, 8 Feb 2022 12:11:59 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]( application to AI research )
Content-Language: en-US
Newsgroups: comp.ai.philosophy,comp.theory,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com> <d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com> <stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad> <o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com> <feXLJ.39132$%uX7.7402@fx38.iad> <2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com> <hU0MJ.10309$r6p7.7703@fx41.iad> <suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com> <AF7MJ.13063$ZmJ7.6019@fx06.iad> <xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com> <9biMJ.10134$Wdl5.2747@fx44.iad> <SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com> <HEjMJ.6348$979a.2933@fx14.iad> <EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com> <f15c6f31-6a9c-4682-b76c-ea75adc47da6n@googlegroups.com>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <f15c6f31-6a9c-4682-b76c-ea75adc47da6n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <TJSdna7Ju4PtL5__nZ2dnUU7-aPNnZ2d@giganews.com>
Lines: 176
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pJaKIHVU/yxNC9/QJ/3+2PDJuvLH6LHASvhyhXM7PtOYZrDPl8Pby1ZAvXwO3Tlj+QPNqLCXAaWKnPU!K8ndVpuk6wBC7EQ5/tmkCS6Qz7pefwd+TG+khM3ZjFHbEKUBZGXXMc4QD2V1Wopd7ed+wGizBshG
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: 10075
 by: olcott - Tue, 8 Feb 2022 18:11 UTC

On 2/8/2022 4:55 AM, Don Stockbauer wrote:
> On Monday, February 7, 2022 at 7:52:39 PM UTC-6, olcott wrote:
>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>> On 2/7/22 8:08 PM, olcott wrote:
>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is incomplete because it does not cover the case where
>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>>>>>>>> proof that the halting problem is undecidable. That is all
>>>>>>>>>>>>>> that I need to refute these proofs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>>> that every Turing machine either halts or matches one of these
>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To solve the halting problem my program must be all knowing.
>>>>>>>>>>>>>> To refute the proofs I merely need to show that their
>>>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>>>> halts, and since H, to be an accurate Halt Decider, must only
>>>>>>>>>>>>> go to H,Qn if the machine its input represents will never
>>>>>>>>>>>>> halt. They you also don't seem to understand that the
>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied to <H^>.
>>>>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, you haven't actually proved the thing you claim youhave,
>>>>>>>>>>>>> but only that you have amassed an amazing pile of unsound
>>>>>>>>>>>>> logic based on wrong definitions that have hoodwinked
>>>>>>>>>>>>> yourself into thinking you have shown something useful.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>> yourself so you can't actually understand what actual Truth is.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You simply do know know enough computer science to understand
>>>>>>>>>>>> that you are wrong and never will because you believe that you
>>>>>>>>>>>> are right.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>>>>> about it.
>>>>>>>>>>>
>>>>>>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>>> whether or not their correctly simulated input could ever
>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>
>>>>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>>>> the behavior of Computation that it is representation of, which
>>>>>>>>>>> for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition of
>>>>>>>>>> a sequence of configurations that never halts.
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>>>
>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't reach
>>>>>>>>> a final state, then it shows its input never halts.
>>>>>>>> When embedded_H matches this infinite pattern in the same three
>>>>>>>> iterations:
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
>>>>>>>> ⟨Ĥ3⟩
>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
>>>>>>>> ⟨Ĥ4⟩
>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>>>>>> ⟨Ĥ5⟩...
>>>>>>>>
>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>>>>>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>>>>>>> input cannot possibly meet the Linz definition of halting:
>>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>
>>>>>>> OK, so the only computatiopn that you show that does not halt is H,
>>>>>>> so H can not be a decider.
>>>>>>
>>>>>> In the above example embedded_H simulates three iterations of nested
>>>>>> simulation to match the infinitely nested simulation pattern.
>>>>>> In reality it needs less than this to match this pattern.
>>>>>>
>>>>>>
>>>>>
>>>>> And if it doesn't do an infinite number, the H^ that is using it will
>>>>> Halt,
>>>>
>>>> embedded_H only examines the actual behavior of its inputs as if its
>>>> was a guard assigned to watch the front. If someone comes in the back
>>>> door (non-inputs) embedded_H is not even allowed to pay attention.
>>>>
>>>
>>> If the 'actual behavior' of the input <H^> <H^> is not the behavior of
>>> H^ applied to <H^> you are lying about doing the Halting Problem.
>>>
>>
>> If it is true that the simulated input to embedded_H cannot possibly
>> ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the universe can
>> possibly contradict the fact that the input specifies a non-halting
>> sequences of configurations. If God himself said otherwise then God
>> himself would be a liar.
>>
>> If we know that we have a black cat then we know that we have a cat.
>>
>> If we know that we have a sequence of configurations that cannot
>> possibly ever reach its final state then we know that we have a
>> non-halting sequence of configurations.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> If someone is obsessed with halting how do you ever halt them?


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<lyDMJ.18606$z688.8500@fx35.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <stu2kf$4hg$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 263
Message-ID: <lyDMJ.18606$z688.8500@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 8 Feb 2022 19:04:33 -0500
X-Received-Bytes: 13718
X-Original-Bytes: 13584
 by: Richard Damon - Wed, 9 Feb 2022 00:04 UTC

On 2/8/22 10:35 AM, olcott wrote:
> On 2/8/2022 5:56 AM, Richard Damon wrote:
>> On 2/8/22 12:28 AM, olcott wrote:
>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>
>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts
>>>>>>>>>>>>>>>>>>> its simulation and
>>>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the case
>>>>>>>>>>>>>>>>>> where the
>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It covers the case that had previously been considered
>>>>>>>>>>>>>>>>> to be proof that the halting problem is undecidable.
>>>>>>>>>>>>>>>>> That is all that I need to refute these proofs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>>>>>> that every Turing machine either halts or matches one
>>>>>>>>>>>>>>>>>> of these
>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show
>>>>>>>>>>>>>>>>> that their counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^>
>>>>>>>>>>>>>>>> <H^> goes to H.Qn, then by construction H^ <H^> goes to
>>>>>>>>>>>>>>>> H^.Qn, and halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>>>> Decider, must only go to H,Qn if the machine its input
>>>>>>>>>>>>>>>> represents will never halt. They you also don't seem to
>>>>>>>>>>>>>>>> understand that the computaton that <H^> <H^> represents
>>>>>>>>>>>>>>>> IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing pile
>>>>>>>>>>>>>>>> of unsound logic based on wrong definitions that have
>>>>>>>>>>>>>>>> hoodwinked yourself into thinking you have shown
>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>>>>> yourself so you can't actually understand what actual
>>>>>>>>>>>>>>>> Truth is.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>> understand that you are wrong and never will because you
>>>>>>>>>>>>>>> believe that you are right.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you clearly don't know enough Computation Theory to
>>>>>>>>>>>>>> talk about it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders they
>>>>>>>>>>>>>>> are only accountable for computing the mapping from their
>>>>>>>>>>>>>>> input finite strings to an accept or reject state on the
>>>>>>>>>>>>>>> basis of whether or not their correctly simulated input
>>>>>>>>>>>>>>> could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM which BY
>>>>>>>>>>>>>> DEFINITION exactly matches the behavior of Computation
>>>>>>>>>>>>>> that it is representation of, which for <H^> <H^> is H^
>>>>>>>>>>>>>> applied to <H^>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition
>>>>>>>>>>>>> to ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz
>>>>>>>>>>>>> definition of a sequence of configurations that never halts.
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>
>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't
>>>>>>>>>>>> reach a final state, then it shows its input never halts.
>>>>>>>>>>> When embedded_H matches this infinite pattern in the same
>>>>>>>>>>> three iterations:
>>>>>>>>>>>
>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>
>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>> will never reach ⟨Ĥ⟩.qn in any number of steps, which proves
>>>>>>>>>>> that this input cannot possibly meet the Linz definition of
>>>>>>>>>>> halting:
>>>>>>>>>>>
>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> OK, so the only computatiopn that you show that does not halt
>>>>>>>>>> is H, so H can not be a decider.
>>>>>>>>>
>>>>>>>>> In the above example embedded_H simulates three iterations of
>>>>>>>>> nested simulation to match the infinitely nested simulation
>>>>>>>>> pattern.
>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And if it doesn't do an infinite number, the H^ that is using it
>>>>>>>> will Halt,
>>>>>>>
>>>>>>> embedded_H only examines the actual behavior of its inputs as if
>>>>>>> its was a guard assigned to watch the front. If someone comes in
>>>>>>> the back door (non-inputs) embedded_H is not even allowed to pay
>>>>>>> attention.
>>>>>>>
>>>>>>
>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>> behavior of H^ applied to <H^> you are lying about doing the
>>>>>> Halting Problem.
>>>>>>
>>>>>
>>>>> If it is true that the simulated input to embedded_H cannot
>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the
>>>>> universe can possibly contradict the fact that the input specifies
>>>>> a non-halting sequences of configurations. If God himself said
>>>>> otherwise then God himself would be a liar.
>>>>>
>>>>
>>>> Except that if H/embedded_H aborts its simulation and goes to H.Qn,
>>>> then the CORRECT simulation of its input (that done by a REAL UTM)
>>>> will show that it will go to H^.Qn.
>>>>
>>>> All you have proven is that if H doesn't abort, and thus doesn't go
>>>> to H.Qn, and thus fails to be a correct decider, then H^ applied to
>>>> <H^> is non-halting.
>>>>
>>>> You keep on thinking that a simulation that aborts its simulation is
>>>> a 'correct' simulation. By the definition in Computation Theory,
>>>> this is not true. If you think it is, it just proves that you don't
>>>> understand the field.
>>>>
>>>> FAIL.
>>>>
>>>>> If we know that we have a black cat then we know that we have a cat.
>>>>
>>>> Except that if you DON'T have a black cat but think you do then you
>>>> are wrong. If H aborts its simulation, it isn't a UTM and doesn't
>>>> 'correctly' simulate.
>>>>
>>>>>
>>>>> If we know that we have a sequence of configurations that cannot
>>>>> possibly ever reach its final state then we know that we have a
>>>>> non-halting sequence of configurations.
>>>>>
>>>>
>>>> Except that is has been PROVEN that if H -> H.Qn then the pattern
>>>> WILL reach the final state.
>>>>
>>>> The fact that H can't ever reach that state proves just proves that
>>>> if H is a UTM, which don't abort, then H^ will be non-halting, but H
>>>> is still wrong for not answering. If H does abort, then it hasn't
>>>> proven anything, and it has been proven that it is wrong.
>>>>
>>>> FAIL
>>>
>>> You are either not bright enough to get this or dishonest.
>>> I don't care which, I need to up my game to computer scientists.
>>>
>>
>> So, can't refute what I say so you go to arguing by insults, classic
>> Olcott logical fallicy.
>>
>
> Fundamentally you seem to lack the intellectual capacity to understand
> what I am saying. This is proven on the basis that what I am saying can
> be verified as true entirely on the basis of the meaning of its words.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]( application to AI research )

<eBDMJ.20111$Y1A7.8512@fx43.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!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.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ](
application to AI research )
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<f15c6f31-6a9c-4682-b76c-ea75adc47da6n@googlegroups.com>
<TJSdna7Ju4PtL5__nZ2dnUU7-aPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <TJSdna7Ju4PtL5__nZ2dnUU7-aPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 194
Message-ID: <eBDMJ.20111$Y1A7.8512@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: Tue, 8 Feb 2022 19:07:37 -0500
X-Received-Bytes: 10486
 by: Richard Damon - Wed, 9 Feb 2022 00:07 UTC

On 2/8/22 1:11 PM, olcott wrote:
> On 2/8/2022 4:55 AM, Don Stockbauer wrote:
>> On Monday, February 7, 2022 at 7:52:39 PM UTC-6, olcott wrote:
>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching infinite
>>>>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H aborts its
>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is incomplete because it does not cover the case where
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite behavior
>>>>>>>>>>>>>>>> pattern".
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It covers the case that had previously been considered to be
>>>>>>>>>>>>>>> proof that the halting problem is undecidable. That is all
>>>>>>>>>>>>>>> that I need to refute these proofs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set of
>>>>>>>>>>>>>>>> patterns such
>>>>>>>>>>>>>>>> that every Turing machine either halts or matches one of
>>>>>>>>>>>>>>>> these
>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To solve the halting problem my program must be all knowing.
>>>>>>>>>>>>>>> To refute the proofs I merely need to show that their
>>>>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^> <H^>
>>>>>>>>>>>>>> goes to H.Qn, then by construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>>>>> halts, and since H, to be an accurate Halt Decider, must only
>>>>>>>>>>>>>> go to H,Qn if the machine its input represents will never
>>>>>>>>>>>>>> halt. They you also don't seem to understand that the
>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied to <H^>.
>>>>>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim youhave,
>>>>>>>>>>>>>> but only that you have amassed an amazing pile of unsound
>>>>>>>>>>>>>> logic based on wrong definitions that have hoodwinked
>>>>>>>>>>>>>> yourself into thinking you have shown something useful.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>>> yourself so you can't actually understand what actual
>>>>>>>>>>>>>> Truth is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You simply do know know enough computer science to understand
>>>>>>>>>>>>> that you are wrong and never will because you believe that you
>>>>>>>>>>>>> are right.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And you clearly don't know enough Computation Theory to talk
>>>>>>>>>>>> about it.
>>>>>>>>>>>>
>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using Computation
>>>>>>>>>>>> Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>>>> whether or not their correctly simulated input could ever
>>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>
>>>>>>>>>>>> And if you are working on the Halting Problem of Computation
>>>>>>>>>>>> Theory, BY DEFINITION, the meaning of 'correcty simulted' is
>>>>>>>>>>>> simulation by a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>>>>> the behavior of Computation that it is representation of, which
>>>>>>>>>>>> for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If an infinite number is steps is not enough steps for the
>>>>>>>>>>> correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets the Linz definition of
>>>>>>>>>>> a sequence of configurations that never halts.
>>>>>>>>>>
>>>>>>>>>> WRONG.
>>>>>>>>>>
>>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't reach
>>>>>>>>>> a final state, then it shows its input never halts.
>>>>>>>>> When embedded_H matches this infinite pattern in the same three
>>>>>>>>> iterations:
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ2⟩
>>>>>>>>> ⟨Ĥ3⟩
>>>>>>>>>     Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ3⟩
>>>>>>>>> ⟨Ĥ4⟩
>>>>>>>>>     Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ4⟩
>>>>>>>>> ⟨Ĥ5⟩...
>>>>>>>>>
>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will
>>>>>>>>> never reach ⟨Ĥ⟩.qn in any number of steps, which proves that this
>>>>>>>>> input cannot possibly meet the Linz definition of halting:
>>>>>>>>>
>>>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>
>>>>>>>> OK, so the only computatiopn that you show that does not halt is H,
>>>>>>>> so H can not be a decider.
>>>>>>>
>>>>>>> In the above example embedded_H simulates three iterations of nested
>>>>>>> simulation to match the infinitely nested simulation pattern.
>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And if it doesn't do an infinite number, the H^ that is using it will
>>>>>> Halt,
>>>>>
>>>>> embedded_H only examines the actual behavior of its inputs as if its
>>>>> was a guard assigned to watch the front. If someone comes in the back
>>>>> door (non-inputs) embedded_H is not even allowed to pay attention.
>>>>>
>>>>
>>>> If the 'actual behavior' of the input <H^> <H^> is not the behavior of
>>>> H^ applied to <H^> you are lying about doing the Halting Problem.
>>>>
>>>
>>> If it is true that the simulated input to embedded_H cannot possibly
>>> ever reach its final state of ⟨Ĥ⟩.qn, then nothing in the universe can
>>> possibly contradict the fact that the input specifies a non-halting
>>> sequences of configurations. If God himself said otherwise then God
>>> himself would be a liar.
>>>
>>> If we know that we have a black cat then we know that we have a cat.
>>>
>>> If we know that we have a sequence of configurations that cannot
>>> possibly ever reach its final state then we know that we have a
>>> non-halting sequence of configurations.
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> If someone is obsessed with halting how do you ever halt them?
>
> I am next to 100% certain that I really did refute the halting problem
> proofs and this has two key benefits for AI research:


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<stv57t$1ist$3@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!7a25jG6pUKCqa0zKnKnvdg.user.46.165.242.75.POSTED!not-for-mail
From: pyt...@example.invalid (Python)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Date: Wed, 9 Feb 2022 02:26:29 +0100
Organization: Aioe.org NNTP Server
Message-ID: <stv57t$1ist$3@gioia.aioe.org>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="52125"; posting-host="7a25jG6pUKCqa0zKnKnvdg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Content-Language: fr
X-Notice: Filtered by postfilter v. 0.9.2
 by: Python - Wed, 9 Feb 2022 01:26 UTC

olcott wrote:
....
> Refuting the halting problem proofs is only a sideline of mine, my
> actual goal is to mathematically formalize the notion of truth. This
> establishes the anchor for Davidson's truth conditional semantics.

You are starting the race with a dead horse.

Pages:1234567
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor