Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

The program isn't debugged until the last user is dead.


computers / comp.ai.philosophy / Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

SubjectAuthor
* Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
+* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|`* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
| `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|  `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|   `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|    `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|     `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|      +* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]Don Stockbauer
|      |`- Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]( appliolcott
|      `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|       +- Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|       `* Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]olcott
|        `* Re: Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|         `* Re: Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|          `* Re: Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|           `* Re: Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|            `* Re: Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|             `* Re: Concise refutation of halting problem proofs V62 [ misconceptionsolcott
|              `* Re: Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|               `* Re: Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|                `* Re: Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|                 `* Re: Concise refutation of halting problem proofs V62 [ self-evident ]olcott
|                  `- Re: Concise refutation of halting problem proofs V62 [ self-evident ]olcott
`* Re: Concise refutation of halting problem proofs V62 [ self-evident ]olcott
 `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
  `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
   `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
    `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
     `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
      `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
       `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
        `* Re: Concise refutation of halting problem proofs V62 [ self-evidentolcott
         `* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
          +- Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
          +- Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
          +* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
          |`* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
          | `- Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
          `* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
           `* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
            `* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
             +* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |`* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             | `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |  `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |   `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |    `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |     `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |      `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |       `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |        `* Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             |         `- Re: Concise refutation of halting problem proofs V62 [ my legacy ](olcott
             `* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
              +* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
              |`- Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
              `* Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott
               `- Re: Concise refutation of halting problem proofs V62 [ my legacy ]olcott

Pages:123
Subject: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sun, 6 Feb 2022 16:31 UTC
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Organization: A noiseless patient Spider
Date: Sun, 6 Feb 2022 20:15 UTC
References: 1 2
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Sun, 6 Feb 2022 20:53 UTC
References: 1 2 3 4
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Mon, 7 Feb 2022 03:04 UTC
References: 1 2 3 4 5 6
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Mon, 7 Feb 2022 04:30 UTC
References: 1 2 3 4 5 6 7 8
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Mon, 7 Feb 2022 14:59 UTC
References: 1 2 3 4 5 6 7 8 9 10
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Tue, 8 Feb 2022 01:08 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Tue, 8 Feb 2022 01:52 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: Don Stockbauer
Newsgroups: comp.ai.philosophy
Date: Tue, 8 Feb 2022 10:55 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
X-Received: by 2002:a05:622a:11ca:: with SMTP id n10mr2505513qtk.567.1644317725025;
Tue, 08 Feb 2022 02:55:25 -0800 (PST)
X-Received: by 2002:a81:5d56:: with SMTP id r83mr3992877ywb.320.1644317724825;
Tue, 08 Feb 2022 02:55:24 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.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.ai.philosophy
Date: Tue, 8 Feb 2022 02:55:24 -0800 (PST)
In-Reply-To: <EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=173.219.77.176; posting-account=iBgNeAoAAADRhzuSC4Ai7MUeMmxtwlM7
NNTP-Posting-Host: 173.219.77.176
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>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <f15c6f31-6a9c-4682-b76c-ea75adc47da6n@googlegroups.com>
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: donstock...@hotmail.com (Don Stockbauer)
Injection-Date: Tue, 08 Feb 2022 10:55:25 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Lines: 192
View all headers
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?


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Organization: A noiseless patient Spider
Date: Tue, 8 Feb 2022 15:35 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
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
View all headers
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.

Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.


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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]( application to AI research )
From: olcott
Newsgroups: comp.ai.philosophy, comp.theory, sci.logic, sci.math
Followup: comp.theory
Date: Tue, 8 Feb 2022 18:11 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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
View all headers
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:

(1) The previously understood absolute limit to the capabilities of computation has been eliminated.

(2) Tarski Undefinability theorem is refuted by proxy thus enabling the notion of truth to be formalized which provides Davidson's truth conditional semantics to be anchored in a formal notion of truth.

--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 9 Feb 2022 01:47 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 08 Feb 2022 19:47:48 -0600
Date: Tue, 8 Feb 2022 19:47:42 -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>
<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>
<stv57t$1ist$3@gioia.aioe.org>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <stv57t$1ist$3@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <XqednSC0JrzZgJ7_nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 22
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XOedrK8GHQ2QaxFIRth+Gvk5axtL+SqPpUWLxqQAEVdHpCUFQjF0Bu67lPYrythchHgCkeSsFL8dyht!WGo/FqhCg2t3/Omdm4COk9ObmV5bnyhgA/18iqh+jrI5YuPuiOROZs5rCYqRbsKK3QzoSPjZZK3M
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: 2851
View all headers
On 2/8/2022 7:26 PM, Python wrote:
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.



If that was true then someone could point to a mistake.
My refutation of the halting problem proofs is isomorphic to Tarski's undefinability theorem and Gödel's 1931 Incompleteness theorem, refuting all three with essentially the same reasoning.

--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 9 Feb 2022 13:13 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
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: Wed, 09 Feb 2022 07:13:13 -0600
Date: Wed, 9 Feb 2022 07:13:12 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
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>
<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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <udOMJ.5581$0vE9.5549@fx17.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
Lines: 344
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6WKZRoYeHRCDvnVAAOsErxgLDmiwGyQXlfm+dxYcV2Gf7besYiO1tuFDA1+PPX0xNwpvWlQDdaNofyt!LqxQJeHg6Ho5VNKikPlsG+iHXxIsIJaK9i5gJ7cryPJ2+ObtjZ8iWAf+oGUR0K5a1j4K4+B+/hN6
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: 18808
View all headers
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.



Just proves you aren't working on the Halting Problem, as the DEFINITION of the Halting problems says that it is, because you don't actually understand the meaning of 'actual behavior'.

From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w halts, and to H,Qn if M applied to w will never halt.


If you are supposed to report when Bill arrives at your house and Sam arrives at you house and you really really believe that Sam's arrival is a valid proxy for Bill's arrival then when I ask you did Bill arrive at your house? you say "yes" even though correct the answer is "no".

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 9 Feb 2022 16:31 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Wed, 09 Feb 2022 10:31:06 -0600
Date: Wed, 9 Feb 2022 10:31:05 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <4mPMJ.19776$iK66.4863@fx46.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
Lines: 362
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EWQIq2lEGEB/JOjsDWret22ln/2KI4LnJmw3f9C7SM8pU6G7RVRfEKlzqNC4Vzx6UosA3d0SWpMwbB/!WvCAVUngaA5KGMDQNdFNYB1r9BLRf2gvvEeIiijUdfHKv1GrORuISM/f6oe4JrRYBIMfFcltI9TR
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: 20181
View all headers
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.



Just proves you aren't working on the Halting Problem, as the DEFINITION of the Halting problems says that it is, because you don't actually understand the meaning of 'actual behavior'.

From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w halts, and to H,Qn if M applied to w will never halt.


If you are supposed to report when Bill arrives at your house and Sam arrives at you house and you really really believe that Sam's arrival is a valid proxy for Bill's arrival then when I ask you did Bill arrive at your house? you say "yes" even though correct the answer is "no".

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 9 Feb 2022 17:08 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Wed, 09 Feb 2022 11:08:42 -0600
Date: Wed, 9 Feb 2022 11:08:41 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <KgSMJ.47860$t2Bb.36697@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
Lines: 377
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ORqsFAEk9O/bIGfY0t2aTE7ceXnGlNVnJx2o0lpLWzCxCKtQPPiLdo3l6aGXOluGDOfru6ZoQI1+7YE!E/xCyF4BPD2kNv79sHtP15osZL/HZetNdBjrX4RaOatqqeRZmOBbNrYRMj3GCf8Hdw+WkPCaY2vz
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: 21192
View all headers
On 2/9/2022 10:49 AM, Richard Damon wrote:
On 2/9/22 11:31 AM, olcott wrote:
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.



Just proves you aren't working on the Halting Problem, as the DEFINITION of the Halting problems says that it is, because you don't actually understand the meaning of 'actual behavior'.

From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w halts, and to H,Qn if M applied to w will never halt.


If you are supposed to report when Bill arrives at your house and Sam arrives at you house and you really really believe that Sam's arrival is a valid proxy for Bill's arrival then when I ask you did Bill arrive at your house? you say "yes" even though correct the answer is "no".

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 9 Feb 2022 18:39 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Wed, 09 Feb 2022 12:39:45 -0600
Date: Wed, 9 Feb 2022 12:39:44 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <zXSMJ.7936$979a.7156@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
Lines: 409
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-C4o3d8CWIe/bchEr9rxzyxRvIx00XgDSM8LS3sznxV3sbVhm33Q6nn9sNY5rE8bGxhhqa5GgtNRlCb3!hmZXsSTTOPOLfNu/fBordT24+uFsKDmjOC/Dhp9F9Num3SIbYWWsx1qO9yx+GGPpOGSf0Ntkyn3x
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: 23076
View all headers
On 2/9/2022 11:35 AM, Richard Damon wrote:
On 2/9/22 12:08 PM, olcott wrote:
On 2/9/2022 10:49 AM, Richard Damon wrote:
On 2/9/22 11:31 AM, olcott wrote:
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.



Just proves you aren't working on the Halting Problem, as the DEFINITION of the Halting problems says that it is, because you don't actually understand the meaning of 'actual behavior'.

From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w halts, and to H,Qn if M applied to w will never halt.

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Wed, 9 Feb 2022 18:56 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Wed, 09 Feb 2022 18:55:39 +0000
Date: Wed, 9 Feb 2022 12:56:08 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <i0UMJ.29891$Lbb6.12914@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
Lines: 433
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-khC7apQVKGvaNI2T5pXX955WLzYXo5okyq8suklRPmve6WNIO7nbVAAsM2xS3KG5fBQoIm0HRGWIogk!euye4ZQj4yl8V7WbW9hj+cygmAikxegwy6Wgt4WYsPpw+qLcbdx9h+PwxslcbK6EbNmHN4S3TenM
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: 24802
View all headers
On 2/9/2022 12:48 PM, Richard Damon wrote:

On 2/9/22 1:39 PM, olcott wrote:
On 2/9/2022 11:35 AM, Richard Damon wrote:
On 2/9/22 12:08 PM, olcott wrote:
On 2/9/2022 10:49 AM, Richard Damon wrote:
On 2/9/22 11:31 AM, olcott wrote:
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.



Just proves you aren't working on the Halting Problem, as the DEFINITION of the Halting problems says that it is, because you don't actually understand the meaning of 'actual behavior'.

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Organization: A noiseless patient Spider
Date: Wed, 9 Feb 2022 19:37 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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 [ misconceptions
]
Followup-To: comp.theory
Date: Wed, 9 Feb 2022 13:37:57 -0600
Organization: A noiseless patient Spider
Lines: 451
Message-ID: <su156n$292$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 9 Feb 2022 19:37:59 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="52880b110edbd35d3ee01e686669fd61";
logging-data="2338"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18P8pMUQ6QEz1F4FKJ/Slrr"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Cancel-Lock: sha1:Vq3vXB1xjodZiNVLqAH9foaC1QU=
In-Reply-To: <stUMJ.47863$t2Bb.14394@fx98.iad>
Content-Language: en-US
View all headers
On 2/9/2022 1:19 PM, Richard Damon wrote:
On 2/9/22 1:56 PM, olcott wrote:
On 2/9/2022 12:48 PM, Richard Damon wrote:

On 2/9/22 1:39 PM, olcott wrote:
On 2/9/2022 11:35 AM, Richard Damon wrote:
On 2/9/22 12:08 PM, olcott wrote:
On 2/9/2022 10:49 AM, Richard Damon wrote:
On 2/9/22 11:31 AM, olcott wrote:
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.



Just proves you aren't working on the Halting Problem, as the DEFINITION of the Halting problems says that it is, because you don't actually understand the meaning of 'actual behavior'.

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Thu, 10 Feb 2022 01:45 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
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: Wed, 09 Feb 2022 19:46:02 -0600
Date: Wed, 9 Feb 2022 19:45:59 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad> <su1bj6$qko$1@dont-email.me>
<J_WMJ.41239$%uX7.34935@fx38.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <J_WMJ.41239$%uX7.34935@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
Lines: 513
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fUxCG/wVJjoGbSbcPyA1PnT8n/47U5w19lAFEMguCrjKmTXa/NJmhxHzxNqk8JDEGEFFiXTfNd1U6IT!lRvZ82CyPOAzh5xL5kjFNbkEbFtIKQUyaDnnmG3ftxZkputD8JCdEnU73RVYA6axSC83nYL4rrWF
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: 31075
View all headers
On 2/9/2022 4:11 PM, Richard Damon wrote:
On 2/9/22 4:27 PM, olcott wrote:
On 2/9/2022 3:14 PM, Richard Damon wrote:
On 2/9/22 4:03 PM, olcott wrote:
On 2/9/2022 2:12 PM, Richard Damon wrote:

On 2/9/22 2:37 PM, olcott wrote:
On 2/9/2022 1:19 PM, Richard Damon wrote:
On 2/9/22 1:56 PM, olcott wrote:
On 2/9/2022 12:48 PM, Richard Damon wrote:

On 2/9/22 1:39 PM, olcott wrote:
On 2/9/2022 11:35 AM, Richard Damon wrote:
On 2/9/22 12:08 PM, olcott wrote:
On 2/9/2022 10:49 AM, Richard Damon wrote:
On 2/9/22 11:31 AM, olcott wrote:
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

No, you need to learn that words have PRECISE meanings, and you aren't allowed to change them, no mwtter how much it 'makes sense' to do so.


The key mistake that my reviewers are making is that they believe that the halt decider is supposed to evaluate its input on the basis of some proxy for the actual behavior of this actual input rather than the actual behavior specified by this actual input.

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Thu, 10 Feb 2022 14:18 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Thu, 10 Feb 2022 08:18:48 -0600
Date: Thu, 10 Feb 2022 08:18:45 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad> <su1bj6$qko$1@dont-email.me>
<J_WMJ.41239$%uX7.34935@fx38.iad>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
<gA%MJ.54112$SeK9.9434@fx97.iad>
<L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com> <MZ%MJ.432$uW1.244@fx27.iad>
<h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
<gK0NJ.10652$GjY3.402@fx01.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <gK0NJ.10652$GjY3.402@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
Lines: 645
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-UY8iKziT1y3jFh5UsurWfwDrvuEzweusqaXiM7ZmvieeKLp9ttBRf7ybMAIbrMthn/a/kNROscCdFaY!AsBbEnZQ1UHpYmjvAwEuTnM8M/zGHl9ooMRRtKtlW77oe3hLXWyDf0gwgvHZ+ikwYI6socZhOL3I
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: 40285
View all headers
On 2/9/2022 10:43 PM, Richard Damon wrote:
On 2/9/22 11:06 PM, olcott wrote:
On 2/9/2022 9:52 PM, Richard Damon wrote:
On 2/9/22 10:31 PM, olcott wrote:
On 2/9/2022 9:25 PM, Richard Damon wrote:
On 2/9/22 10:07 PM, olcott wrote:
On 2/9/2022 8:09 PM, Richard Damon wrote:
On 2/9/22 8:45 PM, olcott wrote:
On 2/9/2022 4:11 PM, Richard Damon wrote:
On 2/9/22 4:27 PM, olcott wrote:
On 2/9/2022 3:14 PM, Richard Damon wrote:
On 2/9/22 4:03 PM, olcott wrote:
On 2/9/2022 2:12 PM, Richard Damon wrote:

On 2/9/22 2:37 PM, olcott wrote:
On 2/9/2022 1:19 PM, Richard Damon wrote:
On 2/9/22 1:56 PM, olcott wrote:
On 2/9/2022 12:48 PM, Richard Damon wrote:

On 2/9/22 1:39 PM, olcott wrote:
On 2/9/2022 11:35 AM, Richard Damon wrote:
On 2/9/22 12:08 PM, olcott wrote:
On 2/9/2022 10:49 AM, Richard Damon wrote:
On 2/9/22 11:31 AM, olcott wrote:
On 2/9/2022 7:30 AM, Richard Damon wrote:

On 2/9/22 8:13 AM, olcott wrote:
On 2/9/2022 6:13 AM, Richard Damon wrote:
On 2/8/22 9:19 PM, olcott wrote:
On 2/8/2022 7:39 PM, Richard Damon wrote:
On 2/8/22 7:31 PM, olcott wrote:
On 2/8/2022 6:04 PM, Richard Damon wrote:
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.

Except that it has been shown that you keep on using the WRONG definitions of the words.

A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY repoduces the behavior of its input (so if it is non-halting, so will the UTM). Also you think that there can be a 'Correct Simulation' by something that is NOT actully a UTM.

Care to show anywhere where your misdefinitions are support in the field fo Computation Theory.

That just PROVES that you aren't actually working on the Halting Problem of Computation Theory.


Face it, you are just WRONG about your assertions, maybe because you just don't know the field, so don't have any idea what is legal or not.

Also note, you keep talking about needing 'Computer Scientists' to understand, that is really incorrect, you need to be able to explain it to someone who understands Computation Theory, which is a fairly specialized branch of Mathematics. Yes, it is part of the foundation of Computer Science, but isn't the sort of thing that a normal Computer Scientist will deal with day to day.

I need someone to analyze what I am saying on the deep meaning of what I am saying instead of mere rote memorized meanings from textbooks.

Click here to read the complete article
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 11 Feb 2022 03:58 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!2.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 10 Feb 2022 21:58:08 -0600
Date: Thu, 10 Feb 2022 21:58:06 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad> <su1bj6$qko$1@dont-email.me>
<J_WMJ.41239$%uX7.34935@fx38.iad>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
<gA%MJ.54112$SeK9.9434@fx97.iad>
<L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com> <MZ%MJ.432$uW1.244@fx27.iad>
<h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
<gK0NJ.10652$GjY3.402@fx01.iad>
<yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
<iIhNJ.49765$t2Bb.3985@fx98.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <iIhNJ.49765$t2Bb.3985@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3RJIxgkYUWsSmaBQ3ZXJ7PIcDXZmXmQuaYt+tEvjlY8uWOSwshySOT1+E/NVz8DPpaNUMrdxqVLXoU6!WXryR8JErHexRYiS+lglElFdTjn1uu4sujm+RnO9cKD3JmO4l1sM6QQHBXB/gN3YkeJH2o8yBWoP
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: 4067
View all headers
On 2/10/2022 6:02 PM, Richard Damon wrote:

On 2/10/22 9:18 AM, olcott wrote:

  > I explain how I am necessarily correct on the basis of the meaning of my
words and you disagree on the basis of your failure to correctly understand the meaning of these words.

No, you CLAIM to explain based on the meaning of the words, but use the wrong meaning of the words.


THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number of steps that the pure UTM simulation of its input would never reach the final state of this input then it can correctly reject this input as non-halting.


IF it correctly decided, then yes.

But it has been shown, by the definition of the construction method of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and Halts, and thus by the definition of a UTM, then we also have that UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).

(2) Stopping running because the simulation was aborted versus
halting by reaching the final state (we only look at the latter).

We know that the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by either (a UTM or embedded_H) at Ĥ.qx cannot possibly reach ⟨Ĥ⟩.qn thus conclusively proving that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies 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


Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 11 Feb 2022 04:39 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
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: Thu, 10 Feb 2022 22:39:24 -0600
Date: Thu, 10 Feb 2022 22:39:23 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad> <su1bj6$qko$1@dont-email.me>
<J_WMJ.41239$%uX7.34935@fx38.iad>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
<gA%MJ.54112$SeK9.9434@fx97.iad>
<L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com> <MZ%MJ.432$uW1.244@fx27.iad>
<h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
<gK0NJ.10652$GjY3.402@fx01.iad>
<yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
<iIhNJ.49765$t2Bb.3985@fx98.iad>
<jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>
<eulNJ.3627$9%C9.2761@fx21.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <eulNJ.3627$9%C9.2761@fx21.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <9eudnVHH7rbhdZj_nZ2dnUU7-L3NnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PA3M781HGw4tmeRWFDc9vM8bJgCtJ+WGHi40JxVgN/T5a/bujdhyhQDDXFtpE6IuNN65doWeQV22D6i!a6PU8hwtO/RAPaG1In76W2e4p9enhfnbHzuUnakK5C0DMYhlLtT5zttsid2aTez92eQ6keBSqFL+
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: 4163
View all headers
On 2/10/2022 10:20 PM, Richard Damon wrote:
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:

On 2/10/22 9:18 AM, olcott wrote:

  > I explain how I am necessarily correct on the basis of the meaning of my
words and you disagree on the basis of your failure to correctly understand the meaning of these words.

No, you CLAIM to explain based on the meaning of the words, but use the wrong meaning of the words.


THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number of steps that the pure UTM simulation of its input would never reach the final state of this input then it can correctly reject this input as non-halting.


IF it correctly decided, then yes.

But it has been shown, by the definition of the construction method of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and Halts, and thus by the definition of a UTM, then we also have that UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).

No, YOU qre confused.

By the definioon of how to build H^, embedded_H MUST be EXACTLY the same algorithm as H,

No it is specifically not allowed to be.
embedded_H must have an infinite loop appended to its Ĥ.qy state and H is not allowed to have such a loop appended to its H.qy state.

--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Date: Fri, 11 Feb 2022 15:20 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 11 Feb 2022 09:20:36 -0600
Date: Fri, 11 Feb 2022 09:20:36 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad> <su1bj6$qko$1@dont-email.me>
<J_WMJ.41239$%uX7.34935@fx38.iad>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
<gA%MJ.54112$SeK9.9434@fx97.iad>
<L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com> <MZ%MJ.432$uW1.244@fx27.iad>
<h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
<gK0NJ.10652$GjY3.402@fx01.iad>
<yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
<iIhNJ.49765$t2Bb.3985@fx98.iad>
<jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>
<eulNJ.3627$9%C9.2761@fx21.iad>
<9eudnVHH7rbhdZj_nZ2dnUU7-L3NnZ2d@giganews.com>
<YSrNJ.42370$%uX7.33217@fx38.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <YSrNJ.42370$%uX7.33217@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <r_udnQ1z3P1Z45v_nZ2dnUU7-bGdnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wSGesqX59OKv/UpU8Xj/C20q4sZ2aNLdlz0n5Wdlb5jiE8C63KaW13x/X1CIaqogSGki+92ZJ3IMwni!PmPGM7Ep3aNk3cQB9nShV5qeSrtyZXbb3i86g/ODNU00d+1Gnobmauth3rlcnzzITVLRy3qISj1z
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: 4769
View all headers
On 2/11/2022 5:36 AM, Richard Damon wrote:
On 2/10/22 11:39 PM, olcott wrote:
On 2/10/2022 10:20 PM, Richard Damon wrote:
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:

On 2/10/22 9:18 AM, olcott wrote:

  > I explain how I am necessarily correct on the basis of the meaning of my
words and you disagree on the basis of your failure to correctly understand the meaning of these words.

No, you CLAIM to explain based on the meaning of the words, but use the wrong meaning of the words.


THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number of steps that the pure UTM simulation of its input would never reach the final state of this input then it can correctly reject this input as non-halting.


IF it correctly decided, then yes.

But it has been shown, by the definition of the construction method of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and Halts, and thus by the definition of a UTM, then we also have that UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).

No, YOU qre confused.

By the definioon of how to build H^, embedded_H MUST be EXACTLY the same algorithm as H,

No it is specifically not allowed to be.
embedded_H must have an infinite loop appended to its Ĥ.qy state and H is not allowed to have such a loop appended to its H.qy state.


Which is OUTSIDE the algorithm of H itself, and doesn't affect the behavior of H in deciding to go from Q0 to Qy/Qn.

When the simulating halt decider bases it halt status decision on whether or not the same function is being called with the same inputs the difference between H and embedded_H can change the behavior. A string comparison between the machine description of H and embedded_H yields false.

--
Copyright 2021 Pete Olcott

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


Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Organization: A noiseless patient Spider
Date: Sat, 12 Feb 2022 22:34 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
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 [ self-evident ]
Followup-To: comp.theory
Date: Sat, 12 Feb 2022 16:34:28 -0600
Organization: A noiseless patient Spider
Lines: 131
Message-ID: <su9cln$j16$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<gA%MJ.54112$SeK9.9434@fx97.iad>
<L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com> <MZ%MJ.432$uW1.244@fx27.iad>
<h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
<gK0NJ.10652$GjY3.402@fx01.iad>
<yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
<iIhNJ.49765$t2Bb.3985@fx98.iad>
<jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>
<eulNJ.3627$9%C9.2761@fx21.iad>
<9eudnVHH7rbhdZj_nZ2dnUU7-L3NnZ2d@giganews.com>
<YSrNJ.42370$%uX7.33217@fx38.iad>
<r_udnQ1z3P1Z45v_nZ2dnUU7-bGdnZ2d@giganews.com>
<MpCNJ.7298$0vE9.2894@fx17.iad>
<G7SdndNeQvB3Z5v_nZ2dnUU7-X-dnZ2d@giganews.com>
<v0DNJ.37615$Wdl5.24381@fx44.iad>
<9O2dneBs_K9UmZr_nZ2dnUU7-f3NnZ2d@giganews.com>
<gDDNJ.13122$r6p7.1545@fx41.iad> <su7dh3$ohb$1@dont-email.me>
<C0HNJ.15136$dln7.3130@fx03.iad>
<laGdnZule9a-opr_nZ2dnUU7-LPNnZ2d@giganews.com>
<41ONJ.19304$Wwf9.17892@fx23.iad>
<2P2dnacq_a7WIpr_nZ2dnUU7-KmdnZ2d@giganews.com>
<aGPNJ.33309$3jp8.29525@fx33.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 12 Feb 2022 22:34:31 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="ad0145a7ce8c331a170b7153c8e2d876";
logging-data="19494"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+Z1UqiUNUAApdtBnOE7Prc"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Cancel-Lock: sha1:otv5PYUkje79acd9PxTkvlTSvys=
In-Reply-To: <aGPNJ.33309$3jp8.29525@fx33.iad>
Content-Language: en-US
View all headers
On 2/12/2022 8:41 AM, Richard Damon wrote:
On 2/12/22 9:08 AM, olcott wrote:
On 2/12/2022 6:49 AM, Richard Damon wrote:

On 2/12/22 12:01 AM, olcott wrote:
On 2/11/2022 10:50 PM, Richard Damon wrote:
On 2/11/22 11:36 PM, olcott wrote:
On 2/11/2022 6:58 PM, Richard Damon wrote:
On 2/11/22 7:52 PM, olcott wrote:
On 2/11/2022 6:17 PM, Richard Damon wrote:
On 2/11/22 7:10 PM, olcott wrote:
On 2/11/2022 5:36 PM, Richard Damon wrote:
On 2/11/22 10:20 AM, olcott wrote:
On 2/11/2022 5:36 AM, Richard Damon wrote:
On 2/10/22 11:39 PM, olcott wrote:
On 2/10/2022 10:20 PM, Richard Damon wrote:
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:

On 2/10/22 9:18 AM, olcott wrote:

  > I explain how I am necessarily correct on the basis of the meaning of my
words and you disagree on the basis of your failure to correctly understand the meaning of these words.

No, you CLAIM to explain based on the meaning of the words, but use the wrong meaning of the words.


THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number of steps that the pure UTM simulation of its input would never reach the final state of this input then it can correctly reject this input as non-halting.


IF it correctly decided, then yes.

But it has been shown, by the definition of the construction method of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and Halts, and thus by the definition of a UTM, then we also have that UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).

No, YOU qre confused.

By the definioon of how to build H^, embedded_H MUST be EXACTLY the same algorithm as H,

No it is specifically not allowed to be.
embedded_H must have an infinite loop appended to its Ĥ.qy state and H is not allowed to have such a loop appended to its H.qy state.


Which is OUTSIDE the algorithm of H itself, and doesn't affect the behavior of H in deciding to go from Q0 to Qy/Qn.

When the simulating halt decider bases it halt status decision on whether or not the same function is being called with the same inputs the difference between H and embedded_H can change the behavior. A string comparison between the machine description of H and embedded_H yields false.


No, it can't, not and be a COMPUTATION.

You obviously don't know the meaning of the words, so you are just wrong.

Computation means for ALL copoies, Same input leads to Same Output.
The fact that it is not an exact copy makes a difference.


But it IS.


H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not determine that itself is being called multiple times with the same input. embedded_H does determine that itself is called multiple times with the same input because strcmp(H, embedded_H != 0.


Except that embedded_H does't have a 'representation' of itself to use to make that comparison, so that is just more of your Fairy Dust Powered Unicorn stuff.

It can very easily have a representation of itself, that only requires that it has access to its own machine description.


First, Turing Machines DON'T have access to their own machine description, unless it has been provided as an input

You said that this was impossible.


So, you are agreeing that they can't? Or do you just not understand the logic.
I am agreeing that you contradicted yourself.


How, by saying that the only way a Turing Machine can have a copy of its representation is for it to be given (and H is defined in a way that it can't be given as an extra input)?


No appended infinite loop making H and embedded_H the same
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn

embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* H.qn





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


Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Followup: comp.theory
Organization: A noiseless patient Spider
Date: Tue, 15 Feb 2022 16:49 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
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 [ self-evident ]
Followup-To: comp.theory
Date: Tue, 15 Feb 2022 10:49:23 -0600
Organization: A noiseless patient Spider
Lines: 434
Message-ID: <suglil$dkp$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<fIYNJ.4183$LRj9.3729@fx29.iad>
<G7mdnSFmboThw5X_nZ2dnUU7-WXNnZ2d@giganews.com>
<exZNJ.98392$Rza5.65567@fx47.iad>
<aoCdnfcSnKUy-5X_nZ2dnUU7-aXNnZ2d@giganews.com>
<xXZNJ.38446$Wdl5.5537@fx44.iad>
<ztCdnbKpLJC6AJX_nZ2dnUU7-WednZ2d@giganews.com>
<w96OJ.76395$SeK9.206@fx97.iad>
<1rCdnRW4psaehZT_nZ2dnUU7-VvNnZ2d@giganews.com>
<l4bOJ.5973$kuda.550@fx12.iad>
<8KSdnRooMaz5wpT_nZ2dnUU7-IPNnZ2d@giganews.com>
<DodOJ.37047$Lbb6.31741@fx45.iad>
<aP6dndDBnacS-pT_nZ2dnUU7-anNnZ2d@giganews.com>
<4veOJ.35906$Y1A7.8248@fx43.iad>
<As2dnSSEINq06pT_nZ2dnUU7-eednZ2d@giganews.com>
<wVeOJ.35102$41E7.19078@fx37.iad>
<A-CdnSMdYfQZHZT_nZ2dnUU7-KudnZ2d@giganews.com>
<hmfOJ.40926$Wdl5.7730@fx44.iad>
<L8qdnc1PnZ_-EpT_nZ2dnUU7-RWdnZ2d@giganews.com>
<%ihOJ.13496$GjY3.10711@fx01.iad>
<ZcGdnXE1gbY6PJT_nZ2dnUU7-KudnZ2d@giganews.com>
<geiOJ.14278$jwf9.6136@fx24.iad>
<BtednRZDAaNQUZT_nZ2dnUU7-VHNnZ2d@giganews.com>
<ClrOJ.19559$dln7.7346@fx03.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 15 Feb 2022 16:49:26 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="bd1595bc753a99f87cce5a4ef24e2090";
logging-data="13977"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18wodG8j5RAANNr/8oOnO8a"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Cancel-Lock: sha1:o121s7LbTuZsOInxZGxxCMjvbwo=
In-Reply-To: <ClrOJ.19559$dln7.7346@fx03.iad>
Content-Language: en-US
View all headers
On 2/14/2022 5:49 AM, Richard Damon wrote:
On 2/13/22 10:30 PM, olcott wrote:
On 2/13/2022 7:27 PM, Richard Damon wrote:
On 2/13/22 7:26 PM, olcott wrote:
On 2/13/2022 6:24 PM, Richard Damon wrote:
On 2/13/22 6:08 PM, olcott wrote:
On 2/13/2022 4:11 PM, Richard Damon wrote:
On 2/13/22 5:04 PM, olcott wrote:
On 2/13/2022 3:40 PM, Richard Damon wrote:
On 2/13/22 4:24 PM, olcott wrote:
On 2/13/2022 3:12 PM, Richard Damon wrote:
On 2/13/22 3:18 PM, olcott wrote:
On 2/13/2022 1:57 PM, Richard Damon wrote:
On 2/13/22 2:43 PM, olcott wrote:
On 2/13/2022 11:19 AM, Richard Damon wrote:

On 2/13/22 9:38 AM, olcott wrote:
On 2/13/2022 5:43 AM, Richard Damon wrote:
On 2/13/22 12:54 AM, olcott wrote:
On 2/12/2022 8:22 PM, Richard Damon wrote:
On 2/12/22 9:02 PM, olcott wrote:
On 2/12/2022 7:54 PM, Richard Damon wrote:
On 2/12/22 8:27 PM, olcott wrote:
On 2/12/2022 6:57 PM, Richard Damon wrote:
On 2/12/22 7:37 PM, olcott wrote:
On 2/12/2022 6:25 PM, Richard Damon wrote:
On 2/12/22 6:48 PM, olcott wrote:
On 2/12/2022 5:39 PM, Richard Damon wrote:
On 2/12/22 5:34 PM, olcott wrote:
On 2/12/2022 8:41 AM, Richard Damon wrote:
On 2/12/22 9:08 AM, olcott wrote:
On 2/12/2022 6:49 AM, Richard Damon wrote:

On 2/12/22 12:01 AM, olcott wrote:
On 2/11/2022 10:50 PM, Richard Damon wrote:
On 2/11/22 11:36 PM, olcott wrote:
On 2/11/2022 6:58 PM, Richard Damon wrote:
On 2/11/22 7:52 PM, olcott wrote:
On 2/11/2022 6:17 PM, Richard Damon wrote:
On 2/11/22 7:10 PM, olcott wrote:
On 2/11/2022 5:36 PM, Richard Damon wrote:
On 2/11/22 10:20 AM, olcott wrote:
On 2/11/2022 5:36 AM, Richard Damon wrote:
On 2/10/22 11:39 PM, olcott wrote:
On 2/10/2022 10:20 PM, Richard Damon wrote:
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:

On 2/10/22 9:18 AM, olcott wrote:

  > I explain how I am necessarily correct on the basis of the meaning of my
words and you disagree on the basis of your failure to correctly understand the meaning of these words.

No, you CLAIM to explain based on the meaning of the words, but use the wrong meaning of the words.


THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number of steps that the pure UTM simulation of its input would never reach the final state of this input then it can correctly reject this input as non-halting.


IF it correctly decided, then yes.

But it has been shown, by the definition of the construction method of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and Halts, and thus by the definition of a UTM, then we also have that UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).

No, YOU qre confused.

By the definioon of how to build H^, embedded_H MUST be EXACTLY the same algorithm as H,

No it is specifically not allowed to be.
embedded_H must have an infinite loop appended to its Ĥ.qy state and H is not allowed to have such a loop appended to its H.qy state.


Which is OUTSIDE the algorithm of H itself, and doesn't affect the behavior of H in deciding to go from Q0 to Qy/Qn.

When the simulating halt decider bases it halt status decision on whether or not the same function is being called with the same inputs the difference between H and embedded_H can change the behavior. A string comparison between the machine description of H and embedded_H yields false.


No, it can't, not and be a COMPUTATION.

You obviously don't know the meaning of the words, so you are just wrong.

Computation means for ALL copoies, Same input leads to Same Output.
The fact that it is not an exact copy makes a difference.


But it IS.


H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not determine that itself is being called multiple times with the same input. embedded_H does determine that itself is called multiple times with the same input because strcmp(H, embedded_H != 0.


Except that embedded_H does't have a 'representation' of itself to use to make that comparison, so that is just more of your Fairy Dust Powered Unicorn stuff.

It can very easily have a representation of itself, that only requires that it has access to its own machine description.


First, Turing Machines DON'T have access to their own machine description, unless it has been provided as an input

You said that this was impossible.


So, you are agreeing that they can't? Or do you just not understand the logic.
I am agreeing that you contradicted yourself.


How, by saying that the only way a Turing Machine can have a copy of its representation is for it to be given (and H is defined in a way that it can't be given as an extra input)?


No appended infinite loop making H and embedded_H the same
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn

embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* H.qn


Except that the infinite loop isn't part of the copy of H in H^, it is something ADD to it, which only has/affects behavior AFTER H makes its decision.
So another words hypothetical examples get you so confused you totally lose track of everything.


What 'Hypothetical' are you referencing.


This is what I mean when I say that you hardly pay any attention at all.
This is the hypothetical that I am referencing:

No appended infinite loop making H and embedded_H the same
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn



And what do you mean by that?
When I redefine Ĥ to become Ḧ by eliminating its infinite loop, I probably mean: {I redefine Ĥ to become Ḧ by eliminating its infinite loop}.


Which does what? Since if you aren't talking about Linz's H^, your results don't mean anything for the Halting Problem.

It provides a bridge of understanding to my HP refutation.

The key skill that I have applied throughout my career is eliminating "inessential complexity" (1999 Turing award winner Fred Brooks) to make   enormously difficult problems as simple as possible.

https://en.wikipedia.org/wiki/No_Silver_Bullet



But if you eliminate KEY ASPECTS then you aren't talking about what you need to.


It is just like learning arithmetic before attacking algebra.
It lays the foundation of prerequisites for my actual rebuttal.


Just beware that if you make a statement that is only true for a limited case and don't explicitly state so, pointing that out is NOT a 'Dishonest Dodge'.

Since it is know that you are working on trying to prove that a Unicorn exists, what you are saying WILL be looked at in a light anticipating where you are going.

Also remember that showing a rule happens to be correct for one case, doesn't prove that it will be for a different case.


You have gone through all of this before, and it came for nothing, but if this is how you want to spend your last days, knock yourself out.


I think that you already understand that
With Ĥ ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // this path is never taken
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

making Ḧ ⟨Ḧ⟩ an equivalent computation
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn




And, as seems common with your arguments, you keep on forgetting the CONDITIONS on each line.

H^ <H^> is
H^.q0 <H^> -> H^.Qx <H^> <H^>
Then
H^.Qx <H^> <H^> -> H^.Qy -> ∞ IF and only if H <H^> <H^> -> H.Qy and
H^.Qx <H^> <H^> -> H^.Qn If and ohly if H <H^> <H^> => H.Qn.

If you stipulate that H <H^> <H^> will never go to H.Qy, then the behavior on that path can be changed with no effect.

Without the If and only if clauses, the initial description is incorrect because it is incomplete.

So, WITH THE STIPULATION THAT H won't go to H.Qy for either version, then changing H^ to the H" that omits to loop is an equivalence, but ONLY under that stipulation.

This of course shows that H will be wrong about H", as H" will ALWAYS Halt if H answers, and H not answering is always wrong. Thus H will either be wrong for not answering or giving the wrong answer.

I am only making two versions of input to H:
(1) Ĥ WITH an appended infinite loop
(2) Ḧ WITHOUT an appended infinite loop

Only this is being examined:
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩



Right, but the conclusion that H" is 'equivalent' to H^ is only true (if you mean equivalent in the sense that they compute the same function) if it is the case that neither of H <H^> <H^> or H <H"> <H"> go to H.Qy.


Good.

Unless you want to indicate some other definition of 'equivalent' you using (that could be proper to do so here), you need to include the conditions under which the statement is true.


embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ḧ.qn
   and
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn

Click here to read the complete article
Pages:123
rocksolid light 0.7.2
clearneti2ptor