Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Just go with the flow control, roll with the crunches, and, when you get a prompt, type like hell.


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

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 ]( applicationolcott
|      `* 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
Concise refutation of halting problem proofs V62 [ Linz Proof ]

<vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7843&group=comp.ai.philosophy#7843

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 06 Feb 2022 10:31:34 -0600
Date: Sun, 6 Feb 2022 10:31:34 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
Lines: 56
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YOgEDeYfPTvTr/f2ZBDC9uw1ARWwPH4erAbbdYVk0QTCN1H2MV9zxAqpwIur/WNdSmJ2fNHwjX3xka8!Zj/Gs6hOUxDZr78FFdWjo16t3hbIfmHK98y8eWEbchKRGSrEV9Lv+QPTlp03fgRtSyjfHN/0TAHY
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3763
 by: olcott - Sun, 6 Feb 2022 16:31 UTC

Halting problem undecidability and infinitely nested simulation (V3)

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

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

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

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

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

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

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

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

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

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7844&group=comp.ai.philosophy#7844

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

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

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

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

To solve the halting problem my program must be all knowing. To refute
the proofs I merely need to show that their counter-example can be
proved to never halt.

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

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

<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7845&group=comp.ai.philosophy#7845

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 06 Feb 2022 14:53:55 -0600
Date: Sun, 6 Feb 2022 14:53:55 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <UgWLJ.9101$GjY3.7596@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
Lines: 74
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4iwHwPD6BbMUJZM/eNLYiNCA35iSPxYY603ce7vcjmi2dd9HtLGogdD05t9DzU/PK2s0w172E4bONrt!jxFQOot/r90BsR/QURrh0i6Ou5crk4Mxo23X8xYMZortJ4E1ZBGl8TwOf3QyT2obCmi1FnK8b3Q4
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4302
 by: olcott - Sun, 6 Feb 2022 20:53 UTC

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

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

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

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

Halting problem undecidability and infinitely nested simulation (V3)

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

--
Copyright 2021 Pete Olcott

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

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

<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7846&group=comp.ai.philosophy#7846

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 06 Feb 2022 21:04:54 -0600
Date: Sun, 6 Feb 2022 21:04:53 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <feXLJ.39132$%uX7.7402@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 91
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-RHhwe1EeROKKzn8n56LeXsU587Q66v3U9OTEdVEVLIFbJzJl5tCLvJu+jMcWnkNspJkAroD27mrfLKd!3KK3yq62dRIsRPpj3oksIVi72BQP5+xkPmOYIjG75nUJxB4+G2cHWV2Wq7Q4OsQ7Ztq/Ztg/YCYb
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5376
 by: olcott - Mon, 7 Feb 2022 03:04 UTC

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7847&group=comp.ai.philosophy#7847

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 06 Feb 2022 22:30:14 -0600
Date: Sun, 6 Feb 2022 22:30:13 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <hU0MJ.10309$r6p7.7703@fx41.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 106
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ipWqP+vNQNsmXKnBKBFfLqdQc4RlOEbiJW3qT7yVWwfCZ078j5i3Sv2L62k8WHh3L3L61PQWdGU4WVB!QtyCXSrqR94xjQuTjiOZexDaoPuhY3J1K0WDq0u1XlfhFSOwbeBBnWm4jcHFkPdvoPB0S8La3qEw
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6252
 by: olcott - Mon, 7 Feb 2022 04:30 UTC

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

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

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

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

--
Copyright 2021 Pete Olcott

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

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

<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7849&group=comp.ai.philosophy#7849

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 07 Feb 2022 08:59:35 -0600
Date: Mon, 7 Feb 2022 08:59:28 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <AF7MJ.13063$ZmJ7.6019@fx06.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
Lines: 120
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5PqigZRKXrO3E9bVxdM+Jz4JRSllke6Coiyhk5u3r7jCICdPB0iiXbwCXxXhRx3lWXNRGmye8NZu6Vh!IGdsQ5fw1Ne7dqkuck7BKt+c95zP35Cuc6RcAyN1YqrF3KDGSPzhuxg6Xl3S8uu+SaAEDS6i+QIE
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6958
 by: olcott - Mon, 7 Feb 2022 14:59 UTC

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

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

--
Copyright 2021 Pete Olcott

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

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

<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7850&group=comp.ai.philosophy#7850

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 07 Feb 2022 19:08:11 -0600
Date: Mon, 7 Feb 2022 19:08:03 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <9biMJ.10134$Wdl5.2747@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 134
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EU5A23pwGYg6mDlzk5k1M0h8bSrdltIiFujZC0y85t7xwD7QIx6UAYvQXbZyvr6gqdRO8GszcZhBPFQ!TyF+LGij6o4RwI4jTzd1bc65LBs0a0rdLEqG36edzIWKS3CEhkwc7N+vwwJHisG4O6S/XEbCTpvN
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7693
 by: olcott - Tue, 8 Feb 2022 01:08 UTC

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

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

--
Copyright 2021 Pete Olcott

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

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

<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7851&group=comp.ai.philosophy#7851

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

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


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

<f15c6f31-6a9c-4682-b76c-ea75adc47da6n@googlegroups.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7852&group=comp.ai.philosophy#7852

 copy link   Newsgroups: comp.ai.philosophy
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
 by: Don Stockbauer - Tue, 8 Feb 2022 10:55 UTC

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


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

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

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7853&group=comp.ai.philosophy#7853

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

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


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

<TJSdna7Ju4PtL5__nZ2dnUU7-aPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7854&group=comp.ai.philosophy#7854

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

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


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

<XqednSC0JrzZgJ7_nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7856&group=comp.ai.philosophy#7856

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Wed, 9 Feb 2022 01:47 UTC

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

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

<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7857&group=comp.ai.philosophy#7857

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Wed, 9 Feb 2022 13:13 UTC

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".
>>>
>>> You really like to make you Herrings Red, don't you.
>>>
>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w
>>> is based on the behavior of M applied to w.
>>>
>>> YOU are the one making the wrong report.
>>
>> When anyone in the universe defines something besides the actual
>> behavior specified by the input to embedded_H as the only correct halt
>> status criterion measure that might as well say that cats are not
>> animals.
>>
>>
>
> Just shows your problem in comprehension, doesn't it. You just refuse to
> accept the definition because it doesn't match your idea of what you need.
>
> Note, 'The Actual Behavior specifeid by the input' IS precisly defined,
> and it IS the behavior that the input specifes, The input to the decider
> is the description of a computation, and the actual behavior sepecified
> by the input is by defintion the behavior of that computation that the
> input describes.
>
> YOU are the one that wants to change it to not be the behavior specified
> by the input, but the behavior of the program that is processing the
> input. YOUR definition of the behavior has the problem that the behavior
> is no longer just specified by 'the input' but is also a function of
> what program you give that input to.
>
> Your logic is just not sound, and sometimes I wonder how sound your mind
> is.
>
> This statement of your just shows how you have lost touch with the
> reality of the situation. You seem to think the Univese must be wrong
> because it doesn't match your expectations. THAT is a sign of mental
> illness.
>
> FAIL.


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

<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7858&group=comp.ai.philosophy#7858

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Wed, 9 Feb 2022 16:31 UTC

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".
>>>>>
>>>>> You really like to make you Herrings Red, don't you.
>>>>>
>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w
>>>>> is based on the behavior of M applied to w.
>>>>>
>>>>> YOU are the one making the wrong report.
>>>>
>>>> When anyone in the universe defines something besides the actual
>>>> behavior specified by the input to embedded_H as the only correct
>>>> halt status criterion measure that might as well say that cats are
>>>> not animals.
>>>>
>>>>
>>>
>>> Just shows your problem in comprehension, doesn't it. You just refuse
>>> to accept the definition because it doesn't match your idea of what
>>> you need.
>>>
>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>> defined, and it IS the behavior that the input specifes, The input to
>>> the decider is the description of a computation, and the actual
>>> behavior sepecified by the input is by defintion the behavior of that
>>> computation that the input describes.
>>>
>>> YOU are the one that wants to change it to not be the behavior
>>> specified by the input, but the behavior of the program that is
>>> processing the input. YOUR definition of the behavior has the problem
>>> that the behavior is no longer just specified by 'the input' but is
>>> also a function of what program you give that input to.
>>>
>>> Your logic is just not sound, and sometimes I wonder how sound your
>>> mind is.
>>>
>>> This statement of your just shows how you have lost touch with the
>>> reality of the situation. You seem to think the Univese must be wrong
>>> because it doesn't match your expectations. THAT is a sign of mental
>>> illness.
>>>
>>> FAIL.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will never
> Halt.
>
> you keep forgetting the conditions, which are important.
Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can transition
to Ĥ.qn causing Ĥ to transition to Ĥ.qn without contradiction.


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

<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7859&group=comp.ai.philosophy#7859

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Wed, 9 Feb 2022 17:08 UTC

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".
>>>>>>>
>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>
>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM
>>>>>>> w is based on the behavior of M applied to w.
>>>>>>>
>>>>>>> YOU are the one making the wrong report.
>>>>>>
>>>>>> When anyone in the universe defines something besides the actual
>>>>>> behavior specified by the input to embedded_H as the only correct
>>>>>> halt status criterion measure that might as well say that cats are
>>>>>> not animals.
>>>>>>
>>>>>>
>>>>>
>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>> refuse to accept the definition because it doesn't match your idea
>>>>> of what you need.
>>>>>
>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>> defined, and it IS the behavior that the input specifes, The input
>>>>> to the decider is the description of a computation, and the actual
>>>>> behavior sepecified by the input is by defintion the behavior of
>>>>> that computation that the input describes.
>>>>>
>>>>> YOU are the one that wants to change it to not be the behavior
>>>>> specified by the input, but the behavior of the program that is
>>>>> processing the input. YOUR definition of the behavior has the
>>>>> problem that the behavior is no longer just specified by 'the
>>>>> input' but is also a function of what program you give that input to.
>>>>>
>>>>> Your logic is just not sound, and sometimes I wonder how sound your
>>>>> mind is.
>>>>>
>>>>> This statement of your just shows how you have lost touch with the
>>>>> reality of the situation. You seem to think the Univese must be
>>>>> wrong because it doesn't match your expectations. THAT is a sign of
>>>>> mental illness.
>>>>>
>>>>> FAIL.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>> never Halt.
>>>
>>> you keep forgetting the conditions, which are important.
>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
>> than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can transition
>> to Ĥ.qn causing Ĥ to transition to Ĥ.qn without contradiction.
>
> Bing a pathological liar seems to have made you lose your sense of what
> is true.
>
> While H^ applied to <H^> IS a different computation then H applied to
> <H^> <H^> the former uses the latter to determine its behavior.
>
> The issue isn't a 'contradiction' between the behavior of the two
> machines but the contradiction between the behavior of these two
> machines and the concept that H is correct.
>
>>
>> Like the guard that is only accountable for guarding the front door
>> simulating halt decider embedded_H is only accountable for reporting
>> whether or not its simulated input can possibly reach its own final
>> state ⟨Ĥ⟩.qn.
>
> Again, you pathological lying has blinded you to the actual fact.
>
> H/embedded_H IS responsible for its answer match the the ACTUAL
> 'Behavior of its input', which is DEFINED as the behavior of the ACTUAL
> MACHINE the input represents.


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

<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7860&group=comp.ai.philosophy#7860

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Wed, 9 Feb 2022 18:39 UTC

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.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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".
>>>>>>>>>
>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>
>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to
>>>>>>>>> wM w is based on the behavior of M applied to w.
>>>>>>>>>
>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>
>>>>>>>> When anyone in the universe defines something besides the actual
>>>>>>>> behavior specified by the input to embedded_H as the only
>>>>>>>> correct halt status criterion measure that might as well say
>>>>>>>> that cats are not animals.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>>> refuse to accept the definition because it doesn't match your
>>>>>>> idea of what you need.
>>>>>>>
>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>>> defined, and it IS the behavior that the input specifes, The
>>>>>>> input to the decider is the description of a computation, and the
>>>>>>> actual behavior sepecified by the input is by defintion the
>>>>>>> behavior of that computation that the input describes.
>>>>>>>
>>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>>> specified by the input, but the behavior of the program that is
>>>>>>> processing the input. YOUR definition of the behavior has the
>>>>>>> problem that the behavior is no longer just specified by 'the
>>>>>>> input' but is also a function of what program you give that input
>>>>>>> to.
>>>>>>>
>>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>>> your mind is.
>>>>>>>
>>>>>>> This statement of your just shows how you have lost touch with
>>>>>>> the reality of the situation. You seem to think the Univese must
>>>>>>> be wrong because it doesn't match your expectations. THAT is a
>>>>>>> sign of mental illness.
>>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will
>>>>> Halt.
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>>>> never Halt.
>>>>>
>>>>> you keep forgetting the conditions, which are important.
>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
>>>> than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can
>>>> transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn without
>>>> contradiction.
>>>
>>> Bing a pathological liar seems to have made you lose your sense of
>>> what is true.
>>>
>>> While H^ applied to <H^> IS a different computation then H applied to
>>> <H^> <H^> the former uses the latter to determine its behavior.
>>>
>>> The issue isn't a 'contradiction' between the behavior of the two
>>> machines but the contradiction between the behavior of these two
>>> machines and the concept that H is correct.
>>>
>>>>
>>>> Like the guard that is only accountable for guarding the front door
>>>> simulating halt decider embedded_H is only accountable for reporting
>>>> whether or not its simulated input can possibly reach its own final
>>>> state ⟨Ĥ⟩.qn.
>>>
>>> Again, you pathological lying has blinded you to the actual fact.
>>>
>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>> ACTUAL MACHINE the input represents.
>>
>> You have this misconception welded into your brain.
>> That is just like asking did Bill come over last night?
>>
>> You answer yes because Bill's lawyer came over and Bill's lawyer
>> represents Bill.
>>
>>
>
> Say what you will, but the DEFINTION of what a Halt Decider is supposed
> to answer on is the actual behavior of the machine that the input
> represents.
>
If the court is trying to establish an alibi for Bill and you answer
this on the basis that Bill's lawyer instead of Bill you would go to
prison for perjury. This proves that you are not allowed to use the term
"represents" to refer to something else somewhere else.


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

<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7861&group=comp.ai.philosophy#7861

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Wed, 9 Feb 2022 18:56 UTC

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'.
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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".
>>>>>>>>>>>
>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>
>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied
>>>>>>>>>>> to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>
>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>
>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>>> only correct halt status criterion measure that might as well
>>>>>>>>>> say that cats are not animals.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>>>>> refuse to accept the definition because it doesn't match your
>>>>>>>>> idea of what you need.
>>>>>>>>>
>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>>>>> defined, and it IS the behavior that the input specifes, The
>>>>>>>>> input to the decider is the description of a computation, and
>>>>>>>>> the actual behavior sepecified by the input is by defintion the
>>>>>>>>> behavior of that computation that the input describes.
>>>>>>>>>
>>>>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>>>>> specified by the input, but the behavior of the program that is
>>>>>>>>> processing the input. YOUR definition of the behavior has the
>>>>>>>>> problem that the behavior is no longer just specified by 'the
>>>>>>>>> input' but is also a function of what program you give that
>>>>>>>>> input to.
>>>>>>>>>
>>>>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>>>>> your mind is.
>>>>>>>>>
>>>>>>>>> This statement of your just shows how you have lost touch with
>>>>>>>>> the reality of the situation. You seem to think the Univese
>>>>>>>>> must be wrong because it doesn't match your expectations. THAT
>>>>>>>>> is a sign of mental illness.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will
>>>>>>> Halt.
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>>>>>> never Halt.
>>>>>>>
>>>>>>> you keep forgetting the conditions, which are important.
>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn
>>>>>> without contradiction.
>>>>>
>>>>> Bing a pathological liar seems to have made you lose your sense of
>>>>> what is true.
>>>>>
>>>>> While H^ applied to <H^> IS a different computation then H applied
>>>>> to <H^> <H^> the former uses the latter to determine its behavior.
>>>>>
>>>>> The issue isn't a 'contradiction' between the behavior of the two
>>>>> machines but the contradiction between the behavior of these two
>>>>> machines and the concept that H is correct.
>>>>>
>>>>>>
>>>>>> Like the guard that is only accountable for guarding the front
>>>>>> door simulating halt decider embedded_H is only accountable for
>>>>>> reporting whether or not its simulated input can possibly reach
>>>>>> its own final state ⟨Ĥ⟩.qn.
>>>>>
>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>
>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>>> ACTUAL MACHINE the input represents.
>>>>
>>>> You have this misconception welded into your brain.
>>>> That is just like asking did Bill come over last night?
>>>>
>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>> represents Bill.
>>>>
>>>>
>>>
>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>> supposed to answer on is the actual behavior of the machine that the
>>> input represents.
>>>
>> If the court is trying to establish an alibi for Bill and you answer
>> this on the basis that Bill's lawyer instead of Bill you would go to
>> prison for perjury. This proves that you are not allowed to use the
>> term "represents" to refer to something else somewhere else.
>
> So, do you think you should go to jail for the perjury of Ha reporting
> on the behavior of Hn^ instead if Ha^?
>
> That is your wrong answer.
>>
>> When a finite string Turing machine description represents a Turing
>> Machine then the UTM simulation of the finite string will always have
>> computationally equivalent behavior to the direct execution of the
>> Turing machine.
>
> Right, A REAL UTM, which never aborts its simulation, but is non-halting
> if its input represents a non-halting computation, as is part of the
> defintion of a UTM.


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

<su156n$292$1@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7862&group=comp.ai.philosophy#7862

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V62 [ 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
 by: olcott - Wed, 9 Feb 2022 19:37 UTC

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'.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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".
>>>>>>>>>>>>>
>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>
>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied
>>>>>>>>>>>>> to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>
>>>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>>>>> only correct halt status criterion measure that might as
>>>>>>>>>>>> well say that cats are not animals.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You
>>>>>>>>>>> just refuse to accept the definition because it doesn't match
>>>>>>>>>>> your idea of what you need.
>>>>>>>>>>>
>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>> specifes, The input to the decider is the description of a
>>>>>>>>>>> computation, and the actual behavior sepecified by the input
>>>>>>>>>>> is by defintion the behavior of that computation that the
>>>>>>>>>>> input describes.
>>>>>>>>>>>
>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>> program that is processing the input. YOUR definition of the
>>>>>>>>>>> behavior has the problem that the behavior is no longer just
>>>>>>>>>>> specified by 'the input' but is also a function of what
>>>>>>>>>>> program you give that input to.
>>>>>>>>>>>
>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>
>>>>>>>>>>> This statement of your just shows how you have lost touch
>>>>>>>>>>> with the reality of the situation. You seem to think the
>>>>>>>>>>> Univese must be wrong because it doesn't match your
>>>>>>>>>>> expectations. THAT is a sign of mental illness.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^>
>>>>>>>>> Will Halt.
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^>
>>>>>>>>> will never Halt.
>>>>>>>>>
>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to
>>>>>>>> Ĥ.qn without contradiction.
>>>>>>>
>>>>>>> Bing a pathological liar seems to have made you lose your sense
>>>>>>> of what is true.
>>>>>>>
>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>> applied to <H^> <H^> the former uses the latter to determine its
>>>>>>> behavior.
>>>>>>>
>>>>>>> The issue isn't a 'contradiction' between the behavior of the two
>>>>>>> machines but the contradiction between the behavior of these two
>>>>>>> machines and the concept that H is correct.
>>>>>>>
>>>>>>>>
>>>>>>>> Like the guard that is only accountable for guarding the front
>>>>>>>> door simulating halt decider embedded_H is only accountable for
>>>>>>>> reporting whether or not its simulated input can possibly reach
>>>>>>>> its own final state ⟨Ĥ⟩.qn.
>>>>>>>
>>>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>>>
>>>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>>>>> ACTUAL MACHINE the input represents.
>>>>>>
>>>>>> You have this misconception welded into your brain.
>>>>>> That is just like asking did Bill come over last night?
>>>>>>
>>>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>>>> represents Bill.
>>>>>>
>>>>>>
>>>>>
>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>> supposed to answer on is the actual behavior of the machine that
>>>>> the input represents.
>>>>>
>>>> If the court is trying to establish an alibi for Bill and you answer
>>>> this on the basis that Bill's lawyer instead of Bill you would go to
>>>> prison for perjury. This proves that you are not allowed to use the
>>>> term "represents" to refer to something else somewhere else.
>>>
>>> So, do you think you should go to jail for the perjury of Ha
>>> reporting on the behavior of Hn^ instead if Ha^?
>>>
>>> That is your wrong answer.
>>>>
>>>> When a finite string Turing machine description represents a Turing
>>>> Machine then the UTM simulation of the finite string will always
>>>> have computationally equivalent behavior to the direct execution of
>>>> the Turing machine.
>>>
>>> Right, A REAL UTM, which never aborts its simulation, but is
>>> non-halting if its input represents a non-halting computation, as is
>>> part of the defintion of a UTM.
>>
>> When embedded_H correctly determines that the pure simulation of its
>> input by a real UTM would never reach the final state of this input
>> and it makes this determination in a finite number of steps, then it
>> is necessarily correct for embedded_H  to transition to its reject state.
>>
>
> Except that the 'correct determination' was based on the assumption that
> H/embedded_H IS just a UTM,


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

<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7863&group=comp.ai.philosophy#7863

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Thu, 10 Feb 2022 01:45 UTC

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.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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".
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H
>>>>>>>>>>>>>>>>>>> applied to wM w is based on the behavior of M applied
>>>>>>>>>>>>>>>>>>> to w.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When anyone in the universe defines something besides
>>>>>>>>>>>>>>>>>> the actual behavior specified by the input to
>>>>>>>>>>>>>>>>>> embedded_H as the only correct halt status criterion
>>>>>>>>>>>>>>>>>> measure that might as well say that cats are not animals.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Just shows your problem in comprehension, doesn't it.
>>>>>>>>>>>>>>>>> You just refuse to accept the definition because it
>>>>>>>>>>>>>>>>> doesn't match your idea of what you need.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>>>>>>>> specifes, The input to the decider is the description
>>>>>>>>>>>>>>>>> of a computation, and the actual behavior sepecified by
>>>>>>>>>>>>>>>>> the input is by defintion the behavior of that
>>>>>>>>>>>>>>>>> computation that the input describes.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>>>>>>>> behavior specified by the input, but the behavior of
>>>>>>>>>>>>>>>>> the program that is processing the input. YOUR
>>>>>>>>>>>>>>>>> definition of the behavior has the problem that the
>>>>>>>>>>>>>>>>> behavior is no longer just specified by 'the input' but
>>>>>>>>>>>>>>>>> is also a function of what program you give that input to.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder
>>>>>>>>>>>>>>>>> how sound your mind is.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This statement of your just shows how you have lost
>>>>>>>>>>>>>>>>> touch with the reality of the situation. You seem to
>>>>>>>>>>>>>>>>> think the Univese must be wrong because it doesn't
>>>>>>>>>>>>>>>>> match your expectations. THAT is a sign of mental illness.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^
>>>>>>>>>>>>>>> <H^> Will Halt.
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^
>>>>>>>>>>>>>>> <H^> will never Halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> therefore embedded_H can transition to Ĥ.qn causing Ĥ to
>>>>>>>>>>>>>> transition to Ĥ.qn without contradiction.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Bing a pathological liar seems to have made you lose your
>>>>>>>>>>>>> sense of what is true.
>>>>>>>>>>>>>
>>>>>>>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>>>>>>>> applied to <H^> <H^> the former uses the latter to
>>>>>>>>>>>>> determine its behavior.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The issue isn't a 'contradiction' between the behavior of
>>>>>>>>>>>>> the two machines but the contradiction between the behavior
>>>>>>>>>>>>> of these two machines and the concept that H is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Like the guard that is only accountable for guarding the
>>>>>>>>>>>>>> front door simulating halt decider embedded_H is only
>>>>>>>>>>>>>> accountable for reporting whether or not its simulated
>>>>>>>>>>>>>> input can possibly reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again, you pathological lying has blinded you to the actual
>>>>>>>>>>>>> fact.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H/embedded_H IS responsible for its answer match the the
>>>>>>>>>>>>> ACTUAL 'Behavior of its input', which is DEFINED as the
>>>>>>>>>>>>> behavior of the ACTUAL MACHINE the input represents.
>>>>>>>>>>>>
>>>>>>>>>>>> You have this misconception welded into your brain.
>>>>>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>>>>>
>>>>>>>>>>>> You answer yes because Bill's lawyer came over and Bill's
>>>>>>>>>>>> lawyer represents Bill.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Say what you will, but the DEFINTION of what a Halt Decider
>>>>>>>>>>> is supposed to answer on is the actual behavior of the
>>>>>>>>>>> machine that the input represents.
>>>>>>>>>>>
>>>>>>>>>> If the court is trying to establish an alibi for Bill and you
>>>>>>>>>> answer this on the basis that Bill's lawyer instead of Bill
>>>>>>>>>> you would go to prison for perjury. This proves that you are
>>>>>>>>>> not allowed to use the term "represents" to refer to something
>>>>>>>>>> else somewhere else.
>>>>>>>>>
>>>>>>>>> So, do you think you should go to jail for the perjury of Ha
>>>>>>>>> reporting on the behavior of Hn^ instead if Ha^?
>>>>>>>>>
>>>>>>>>> That is your wrong answer.
>>>>>>>>>>
>>>>>>>>>> When a finite string Turing machine description represents a
>>>>>>>>>> Turing Machine then the UTM simulation of the finite string
>>>>>>>>>> will always have computationally equivalent behavior to the
>>>>>>>>>> direct execution of the Turing machine.
>>>>>>>>>
>>>>>>>>> Right, A REAL UTM, which never aborts its simulation, but is
>>>>>>>>> non-halting if its input represents a non-halting computation,
>>>>>>>>> as is part of the defintion of a UTM.
>>>>>>>>
>>>>>>>> When embedded_H correctly determines that the pure simulation of
>>>>>>>> its input by a real UTM would never reach the final state of
>>>>>>>> this input and it makes this determination in a finite number of
>>>>>>>> steps, then it is necessarily correct for embedded_H  to
>>>>>>>> transition to its reject state.
>>>>>>>>
>>>>>>>
>>>>>>> Except that the 'correct determination' was based on the
>>>>>>> assumption that H/embedded_H IS just a UTM,
>>>>>>
>>>>>> That is factually incorrect. embedded_H determines what the
>>>>>> behavior of its input would be if its was simulated by UTM instead
>>>>>> of a simulating halt decider.
>>>>>
>>>>> Right, but in doing so it does NOT change the copy of H inside of
>>>>> H^ into a UTM. The copy of H (you call it embedded_H) must behave
>>>>> exactly like H does. H needs to decide on what a UTM would do with
>>>>> its same input where the copy of H in that input does the same
>>>>> thing as H does.
>>>>>
>>>>> Unless you can show a Turing Machine diferent copies of which
>>>>> behave differently when given the same input, you haven't shown
>>>>> what you need to. (And if you could show that, that by itself would
>>>>> make you famous).
>>>>>
>>>>
>>>> I have a really great answer for this yet deleted it because of your
>>>> subterfuge on the next line.
>>>
>>> What 'subterfuge', that was just a simple statement of facts based on
>>> definitons.
>>>
>>
>> I repeatedly tell you that infinite behavior can be detected in finite
>> steps and you reject this out-of-hand.
>>
>
> I've proven otherwise for this case, but that isn't the issue here. Your
> whole 'proof' that H^ is non-halting is based on the assumption that
> embedded_H is a non-aborting UTM,
No not at all I didn't say anything like this, and I have corrected you
on this mistake many dozens of times.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ self-evident ]

<yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7864&group=comp.ai.philosophy#7864

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Thu, 10 Feb 2022 14:18 UTC

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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You really like to make you Herrings Red,
>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>> that H applied to wM w is based on the
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of M applied to w.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When anyone in the universe defines something
>>>>>>>>>>>>>>>>>>>>>>>>>> besides the actual behavior specified by the
>>>>>>>>>>>>>>>>>>>>>>>>>> input to embedded_H as the only correct halt
>>>>>>>>>>>>>>>>>>>>>>>>>> status criterion measure that might as well
>>>>>>>>>>>>>>>>>>>>>>>>>> say that cats are not animals.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Just shows your problem in comprehension,
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't it. You just refuse to accept the
>>>>>>>>>>>>>>>>>>>>>>>>> definition because it doesn't match your idea
>>>>>>>>>>>>>>>>>>>>>>>>> of what you need.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the
>>>>>>>>>>>>>>>>>>>>>>>>> input' IS precisly defined, and it IS the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior that the input specifes, The input to
>>>>>>>>>>>>>>>>>>>>>>>>> the decider is the description of a
>>>>>>>>>>>>>>>>>>>>>>>>> computation, and the actual behavior sepecified
>>>>>>>>>>>>>>>>>>>>>>>>> by the input is by defintion the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>> that computation that the input describes.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one that wants to change it to not
>>>>>>>>>>>>>>>>>>>>>>>>> be the behavior specified by the input, but the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the program that is processing the
>>>>>>>>>>>>>>>>>>>>>>>>> input. YOUR definition of the behavior has the
>>>>>>>>>>>>>>>>>>>>>>>>> problem that the behavior is no longer just
>>>>>>>>>>>>>>>>>>>>>>>>> specified by 'the input' but is also a function
>>>>>>>>>>>>>>>>>>>>>>>>> of what program you give that input to.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Your logic is just not sound, and sometimes I
>>>>>>>>>>>>>>>>>>>>>>>>> wonder how sound your mind is.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This statement of your just shows how you have
>>>>>>>>>>>>>>>>>>>>>>>>> lost touch with the reality of the situation.
>>>>>>>>>>>>>>>>>>>>>>>>> You seem to think the Univese must be wrong
>>>>>>>>>>>>>>>>>>>>>>>>> because it doesn't match your expectations.
>>>>>>>>>>>>>>>>>>>>>>>>> THAT is a sign of mental illness.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do
>>>>>>>>>>>>>>>>>>>>>>> if H^ <H^> Will Halt.
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do
>>>>>>>>>>>>>>>>>>>>>>> if H^ <H^> will never Halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> you keep forgetting the conditions, which are
>>>>>>>>>>>>>>>>>>>>>>> important.
>>>>>>>>>>>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence
>>>>>>>>>>>>>>>>>>>>>> of configurations than embedded_H applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ therefore embedded_H can transition to Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>> causing Ĥ to transition to Ĥ.qn without
>>>>>>>>>>>>>>>>>>>>>> contradiction.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Bing a pathological liar seems to have made you
>>>>>>>>>>>>>>>>>>>>> lose your sense of what is true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> While H^ applied to <H^> IS a different computation
>>>>>>>>>>>>>>>>>>>>> then H applied to <H^> <H^> the former uses the
>>>>>>>>>>>>>>>>>>>>> latter to determine its behavior.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The issue isn't a 'contradiction' between the
>>>>>>>>>>>>>>>>>>>>> behavior of the two machines but the contradiction
>>>>>>>>>>>>>>>>>>>>> between the behavior of these two machines and the
>>>>>>>>>>>>>>>>>>>>> concept that H is correct.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Like the guard that is only accountable for
>>>>>>>>>>>>>>>>>>>>>> guarding the front door simulating halt decider
>>>>>>>>>>>>>>>>>>>>>> embedded_H is only accountable for reporting
>>>>>>>>>>>>>>>>>>>>>> whether or not its simulated input can possibly
>>>>>>>>>>>>>>>>>>>>>> reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Again, you pathological lying has blinded you to
>>>>>>>>>>>>>>>>>>>>> the actual fact.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H/embedded_H IS responsible for its answer match
>>>>>>>>>>>>>>>>>>>>> the the ACTUAL 'Behavior of its input', which is
>>>>>>>>>>>>>>>>>>>>> DEFINED as the behavior of the ACTUAL MACHINE the
>>>>>>>>>>>>>>>>>>>>> input represents.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You have this misconception welded into your brain.
>>>>>>>>>>>>>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You answer yes because Bill's lawyer came over and
>>>>>>>>>>>>>>>>>>>> Bill's lawyer represents Bill.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Say what you will, but the DEFINTION of what a Halt
>>>>>>>>>>>>>>>>>>> Decider is supposed to answer on is the actual
>>>>>>>>>>>>>>>>>>> behavior of the machine that the input represents.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the court is trying to establish an alibi for Bill
>>>>>>>>>>>>>>>>>> and you answer this on the basis that Bill's lawyer
>>>>>>>>>>>>>>>>>> instead of Bill you would go to prison for perjury.
>>>>>>>>>>>>>>>>>> This proves that you are not allowed to use the term
>>>>>>>>>>>>>>>>>> "represents" to refer to something else somewhere else.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, do you think you should go to jail for the perjury
>>>>>>>>>>>>>>>>> of Ha reporting on the behavior of Hn^ instead if Ha^?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is your wrong answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When a finite string Turing machine description
>>>>>>>>>>>>>>>>>> represents a Turing Machine then the UTM simulation of
>>>>>>>>>>>>>>>>>> the finite string will always have computationally
>>>>>>>>>>>>>>>>>> equivalent behavior to the direct execution of the
>>>>>>>>>>>>>>>>>> Turing machine.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, A REAL UTM, which never aborts its simulation,
>>>>>>>>>>>>>>>>> but is non-halting if its input represents a
>>>>>>>>>>>>>>>>> non-halting computation, as is part of the defintion of
>>>>>>>>>>>>>>>>> a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When embedded_H correctly determines that the pure
>>>>>>>>>>>>>>>> simulation of its input by a real UTM would never reach
>>>>>>>>>>>>>>>> the final state of this input and it makes this
>>>>>>>>>>>>>>>> determination in a finite number of steps, then it is
>>>>>>>>>>>>>>>> necessarily correct for embedded_H  to transition to its
>>>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that the 'correct determination' was based on the
>>>>>>>>>>>>>>> assumption that H/embedded_H IS just a UTM,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is factually incorrect. embedded_H determines what
>>>>>>>>>>>>>> the behavior of its input would be if its was simulated by
>>>>>>>>>>>>>> UTM instead of a simulating halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but in doing so it does NOT change the copy of H
>>>>>>>>>>>>> inside of H^ into a UTM. The copy of H (you call it
>>>>>>>>>>>>> embedded_H) must behave exactly like H does. H needs to
>>>>>>>>>>>>> decide on what a UTM would do with its same input where the
>>>>>>>>>>>>> copy of H in that input does the same thing as H does.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Unless you can show a Turing Machine diferent copies of
>>>>>>>>>>>>> which behave differently when given the same input, you
>>>>>>>>>>>>> haven't shown what you need to. (And if you could show
>>>>>>>>>>>>> that, that by itself would make you famous).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I have a really great answer for this yet deleted it because
>>>>>>>>>>>> of your subterfuge on the next line.
>>>>>>>>>>>
>>>>>>>>>>> What 'subterfuge', that was just a simple statement of facts
>>>>>>>>>>> based on definitons.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I repeatedly tell you that infinite behavior can be detected
>>>>>>>>>> in finite steps and you reject this out-of-hand.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I've proven otherwise for this case, but that isn't the issue
>>>>>>>>> here. Your whole 'proof' that H^ is non-halting is based on the
>>>>>>>>> assumption that embedded_H is a non-aborting UTM,
>>>>>>>> No not at all I didn't say anything like this, and I have
>>>>>>>> corrected you on this mistake many dozens of times.
>>>>>>>>
>>>>>>>
>>>>>>> You might not SAY that you make that assumption, but your proof
>>>>>>> only holds under that condition.
>>>>>>>
>>>>>>
>>>>>> You simply have never been hardly paying any attention at all.
>>>>>>
>>>>>
>>>>> That is just a dishonest dodge because I pointed out something you
>>>>> don't know how to counter.
>>>>>
>>>>
>>>> Your replies always indicate that you didn't bother to hardly pay
>>>> any attention to what I said. Anyone carefully reading them would
>>>> see this.
>>>>
>>>>
>>>
>>> No, YOUR replies are so full of logical falicies I could illustrate a
>>> comprensive book of them with quotes from your writing.
>>>
>>> For instance, you are currently avoiding dealing with the
>>> difficulties I placed on you by making personal attacks.
>>
>> See that you don't even comprehend how the ad hominem fallacy works.
>>
>>
>
> Maybe you don't understand the fallicy. Rather than defending your
> position by showing some logical reason you are right, you 'defend' your
> position by saying I am in some way not 'qualified' to rebut you.
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.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ self-evident ]

<jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7865&group=comp.ai.philosophy#7865

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!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
 by: olcott - Fri, 11 Feb 2022 03:58 UTC

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

Re: Concise refutation of halting problem proofs V62 [ self-evident ]

<9eudnVHH7rbhdZj_nZ2dnUU7-L3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7866&group=comp.ai.philosophy#7866

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: 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
 by: olcott - Fri, 11 Feb 2022 04:39 UTC

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

Re: Concise refutation of halting problem proofs V62 [ self-evident ]

<r_udnQ1z3P1Z45v_nZ2dnUU7-bGdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7867&group=comp.ai.philosophy#7867

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 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
 by: olcott - Fri, 11 Feb 2022 15:20 UTC

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

Re: Concise refutation of halting problem proofs V62 [ self-evident ]

<su9cln$j16$1@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7870&group=comp.ai.philosophy#7870

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V62 [ 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
 by: olcott - Sat, 12 Feb 2022 22:34 UTC

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


Click here to read the complete article
Re: Concise refutation of halting problem proofs V62 [ self-evident ]

<suglil$dkp$1@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7877&group=comp.ai.philosophy#7877

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V62 [ 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
 by: olcott - Tue, 15 Feb 2022 16:49 UTC

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
>>>>>>>>>>>>    nd
>>>>>>>>>>>> H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Problem, embedded_H / H need to transition to a state in H,
>>>>>>>>>>> not some other machine.
>>>>>>>>>>
>>>>>>>>>> As soon as we append an infinite loop to H.y is it no longer H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> This is where you are showing your lack of understanding of
>>>>>>>>> Turing Machines.
>>>>>>>>>
>>>>>>>>> NO ONE has said that the machine where we added the loop is
>>>>>>>>> still the machine H, in fact, Linz calls that machine H', but
>>>>>>>>> H' CONTAINS a complete copy of H, and that copy will still act
>>>>>>>>> exactly like the original H to the point where it gets to the
>>>>>>>>> stat Qy.
>>>>>>>>>
>>>>>>>>> This ability to compose machines of copies of other machines is
>>>>>>>>> basically like the concept of calling subroutines (even if it
>>>>>>>>> is implemented differently) and is fundamental to the design
>>>>>>>>> and analysis of Turing Macines.
>>>>>>>>>
>>>>>>>>> Would you have a problem saying the subroutine H is no longer
>>>>>>>>> the subroutine H if one function just calls H and returns while
>>>>>>>>> a second calls H and conditionally loops? Yes, the whole
>>>>>>>>> program is not H, but the subroutine H is still there and will
>>>>>>>>> behave exactly like it used to in both of the cases.
>>>>>>>>>
>>>>>>>>> One way to map a Turing Machine to ordinary software is to
>>>>>>>>> think of the Q0 state (or whatever is the 'starting' state of
>>>>>>>>> the Turing machine) as the entry point for the function, and
>>>>>>>>> the Halting States of the Turing Machine as retrun stateents
>>>>>>>>> which return a value indicating what state the machine ended in.
>>>>>>>>>
>>>>>>>>> Thus the modifications Linz has done to H are nothing more that
>>>>>>>>> building H^ as mostly a call to H, with code before the call to
>>>>>>>>> manipulate the tape to add the second copy, and code after the
>>>>>>>>> return to loop forever if H returns the 'Halting' answer.
>>>>>>>>>
>>>>>>>>> The Machine/Subroutine H has not been touched at all.
>>>>>>>>
>>>>>>>> My point is that Ĥ ⟨Ĥ⟩ is equivalent to Ḧ ⟨Ḧ⟩
>>>>>>>>
>>>>>>>
>>>>>>> And my point is that they are only equivalent in the normal sense
>>>>>>> of the word if neither of H <H^> <H^> and H <H"> <H"> go to H.Qy
>>>>>>>
>>>>>>> Without that qualification, it is a false statement. PERIOD.
>>>>>>
>>>>>> They are equivalent in that neither can possibly go to their q.y
>>>>>> state.
>>>>>
>>>>>
>>>>> THAT is incorrect without the same
>>>>> qualification/assumption/stipulation, the H doesn't go to Qy.
>>>>>
>>>>
>>>> If H was a white cat detector and you presented H with a black cat
>>>> would it say "yes" ?
>>>>
>>>
>>> But we aren't talking about a 'detector'
>>
>> Sure we are.
>>
>>
>
> Then you don't know what you are talking about (and showing your
> dishonesty by your clipping).
>
> THe claim that H^ and H" are equivilent machines has NOTHING to do with
> there being a 'Detector' but do they behave exactly the same.
So in other words you are disavowing that both ⟨Ĥ⟩ and ⟨Ḧ⟩ have a copy
of H embedded within them ?


Click here to read the complete article
Pages:123
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor