Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"When in doubt, print 'em out." -- Karl's Programming Proverb 0x7


devel / comp.theory / Re: Concise refutation of halting problem proofs V62 [ self-evident ](typo)

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

Pages:1234567
Re: Concise refutation of halting problem proofs V62 [ misconceptions ]

<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>

 copy mid

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

 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 [ misconceptions ]

<8t_MJ.3823$d0Y8.641@fx31.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx31.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 539
Message-ID: <8t_MJ.3823$d0Y8.641@fx31.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 21:09:08 -0500
X-Received-Bytes: 32214
 by: Richard Damon - Thu, 10 Feb 2022 02:09 UTC

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.
>


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

<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 21:07:03 -0600
Date: Wed, 9 Feb 2022 21:07:02 -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
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <8t_MJ.3823$d0Y8.641@fx31.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
Lines: 544
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-y5B/ut82LMDfPSwMAoe6x6aNALsmFyWYpYf2LLr1hoDHXE9f6FUndEHTjpS7jd1/zPhJ325SHGwdtrV!k6CL6S8dSp+T31tjpvqZN6MZL7XMovKfK/7LLp04U3qs5HeBb7qsH+ruNuZy7bOChZRY/VA7ZOvI
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: 32968
 by: olcott - Thu, 10 Feb 2022 03:07 UTC

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.
>


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

<gA%MJ.54112$SeK9.9434@fx97.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx97.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 555
Message-ID: <gA%MJ.54112$SeK9.9434@fx97.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 22:25:00 -0500
X-Received-Bytes: 33651
 by: Richard Damon - Thu, 10 Feb 2022 03:25 UTC

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.
>


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

<L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 21:31:58 -0600
Date: Wed, 9 Feb 2022 21:31:58 -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
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<VuKdnd5V3MLH85n_nZ2dnUU7-VHNnZ2d@giganews.com>
<8t_MJ.3823$d0Y8.641@fx31.iad>
<UaOdnVJQwZbKHJn_nZ2dnUU7-RGdnZ2d@giganews.com>
<gA%MJ.54112$SeK9.9434@fx97.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <gA%MJ.54112$SeK9.9434@fx97.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com>
Lines: 568
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zjHkTVwPjs+eu4+sT00K7FsnG3c9USDoC2CiyoOgS5C7kkl/7z5BRqrUtDGgz2G6S7JCl0iVpr2fSg0!bUxF3ZeXix5psBR9MiJkRMFFXXikCSzXaCThqDveN34rM3QuZJSVqGQXdu19yfax0MWnKMIyOzYa
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: 34904
 by: olcott - Thu, 10 Feb 2022 03:31 UTC

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.
>


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

<MZ%MJ.432$uW1.244@fx27.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx27.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <L-OdnTMEqP6yGpn_nZ2dnUU7-UudnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 588
Message-ID: <MZ%MJ.432$uW1.244@fx27.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 22:52:11 -0500
X-Received-Bytes: 36016
 by: Richard Damon - Thu, 10 Feb 2022 03:52 UTC

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.
>
>


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

<h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 22:06:11 -0600
Date: Wed, 9 Feb 2022 22:06:10 -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
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <MZ%MJ.432$uW1.244@fx27.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
Lines: 605
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-R706jBLJ0XI1YTG4ciVRe6pt/4EHX6nQbjvz5ND4bvdIjifSnx0ODLE6B/L/4tTXI/yDb15J5TZVrVT!QkS94wrR3/N7axJdDbK5Yv0RytgdL5kK3eJ5M3TrK5gaKybDT2Gt8+neTHkeTq2O4MNwlQFN/w6E
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: 37337
 by: olcott - Thu, 10 Feb 2022 04:06 UTC

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.


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

<gK0NJ.10652$GjY3.402@fx01.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <h7adnR_Eer-uEpn_nZ2dnUU7-RednZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 645
Message-ID: <gK0NJ.10652$GjY3.402@fx01.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 23:43:55 -0500
X-Received-Bytes: 39630
 by: Richard Damon - Thu, 10 Feb 2022 04:43 UTC

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.
>
>


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/devel/article-flat.php?id=26454&group=comp.theory#26454

 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 ]

<iIhNJ.49765$t2Bb.3985@fx98.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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>
<yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <yv-dnal-TPpVg5j_nZ2dnUU7-N_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 72
Message-ID: <iIhNJ.49765$t2Bb.3985@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 10 Feb 2022 19:02:21 -0500
X-Received-Bytes: 4704
X-Original-Bytes: 4571
 by: Richard Damon - Fri, 11 Feb 2022 00:02 UTC

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. Thus, by the plain meaning of your words, we know
that H <H^> <H^> could not have correctly determined that its input
would never halt if simulated by a UTM, since we just proved that it does.

All you previous 'proofs' that H was correct in its decision have had
their flaws pointed out, and none of the errors pointed out have been
refuted, so you have ZERO grounds to use your claimed definition that H
is correct in its decision.

The key poiny is that it must CORRECTLY detrmine, which means that it
must use actual sound logic and be looking at the actual case that is to
be proved.

This means that you can't treat embedded_H as a UTM, if H is allowed to
abort is simulation.

You can't argue that an embdded_H can't reach the end in any finite
number of steps before it aborts, as if it does abort, it is no longer
the UTM that your definition requires.

In other words, you definition fails you, because you don't actually
meet it.

FAIL.

> In epistemology (theory of knowledge), a self-evident proposition is a
> proposition that is known to be true by understanding its meaning
> without proof... https://en.wikipedia.org/wiki/Self-evidence
>
>

Then maybe the problem is that epistemolgy isn't compatible with
Computation Theory, or even the whole of Number Theory, or even the
broader field of Formal Logic.

In Formal Logic, the only things that are proved true are those things
that can be derived from the fundamental accepted axioms and accepted
definitipon through the accepted prepositional logic.

If you insist that you can prove something true outside of that, you are
using the wrong logic system so NOTHING you say matters at all.

Guess that just proves that you have been lying about working on the
halting problem. If you don't accept the principles of Formal Logic, you
aren't in the field at all.

FAIL.

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

<jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>

 copy mid

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

 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 ]

<eulNJ.3627$9%C9.2761@fx21.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx21.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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>
<jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <jpKdncRuBKBNQ5j_nZ2dnUU7-XfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 111
Message-ID: <eulNJ.3627$9%C9.2761@fx21.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 10 Feb 2022 23:20:27 -0500
X-Received-Bytes: 6484
 by: Richard Damon - Fri, 11 Feb 2022 04:20 UTC

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, so embedded_H x y must give the exact same behavior as
the computation H x y (if you disagree, provide a actual Turing Machine
and Tape combination that shows this and become famous).

Second, The definition of H from Linz is that H <M> w needs to go to the
final stat H.Qy or H.Qn based on the behavior of M w, which mean that
the computation H <H^> <H^> answer MUST be based on H^ <H^>, since you
claim otherwise, you have just admitted you aren't working on the
Halting Problem, and are just lying about what you are doing.

Yes, embedded_H <H^> <H^> and H^ <H^> are different computations, but
the results of the first needs to correspond to the behavior of the
second. If H^ <H^> Halts, then embeded_H <H^> <H^> needs to go to H.Qy
and if H^ <H^> NEVER Halts, then embedded_H <H^> <H^> needs to go th H.Qn.

Note, that since by construction H^ x goes to H^.Qn and Halt if H x x
goes to H.Qn, it is a logical fact that if H <H^> <H^> goes to H.Qn,
then H^ <H^> also goes to H^.Qn and Halt and thus H failed to meet its
requirement, since for that results of H^ <H^> then H needed to go to
H.Qy to meet its requirements.

DEFINITION.

FAIL.

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

Who said anything about stopping because its simualtion was ab oborted.

The trace of UTM <H^> <H^> is as follows:

H^.Q0 <H^>
H^.Qx <H^> <H^>
which is the identical computaiton as H.Q0 <H^> <H^>
since H.Q0 <H^> <H^> is claimed to go to H.Qn then this goes to H^.Qn
and halts.

This copy of HT^ was never aborted.

This is a faithful trace of UTM <H^> <H^>, unless you point out an
actual error, it will be taken as accepted. (Just disagreing with the
result is NOT pointing out an error).

FAIL.

>
> 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.
>

No, you need to stop confabulating the behavior of H.

Either you are LYING that H <H^> <H^> actual gets to H.Qn to indicate
that it thinks H^ <H^> is non-halt, and by the defintion of 'correctly
deciding' it must. or you are LYING that embedded_H is an actual exact
copy of H, or you are lying that embedded_H acts just like a UTM, or you
are just totally lying that you are even trying to follow the
requrements of the proof.

Which way are you LYING?

You have previous shown that you are not following the rules of the
Halting Problem, so it really needs to be taken as a fact that your
WHOLE ARGUMENT is really just one mosnterous lie that you are actually
doing anything that matters to the Halting Problem.

Unless you retract some of your claims that are in conflict with the
REQUIREMENTS of the Halting Problem, you are just proving that you are
just a pathological liar, and are a total FAILURE in your attempt to
disprove it.

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

<9eudnVHH7rbhdZj_nZ2dnUU7-L3NnZ2d@giganews.com>

 copy mid

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

 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 ]

<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 15 Feb 2022 19:17:30 -0600
Date: Tue, 15 Feb 2022 19:17:29 -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
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9SWOJ.25849$OT%7.13821@fx07.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
Lines: 466
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-F7poN51J7MEG/FTpZDXmmoAUgLe0WL0asboCoqFN5EGDpv+8bum+jENqcgW8smTpQwjNbj3HLshYwli!NjGRBOLciR2pGc2B8r/CxrkBXzdGfXINTfISnj3+mnmkRQ9IDsbsnkjYd5QhyMRIFMeaWINxmaHr
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: 27448
 by: olcott - Wed, 16 Feb 2022 01:17 UTC

On 2/15/2022 5:40 PM, Richard Damon wrote:
>
> On 2/15/22 11:49 AM, olcott wrote:
>> 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 ?
>>
>> A halt detector is the same idea as a halt decider yet a halt detector
>> need not get every input correctly. Every input that the halt detector
>> gets correctly is in the domain of the computable function that it
>> implements.
>>
>>
>
> Yes, they have a copy of the Halt Detector H in them, and unless you are
> willing to stipulate that H will not go to H.Qy when given H^ or H" as
> an input, then you can not show that those machines are equivalent.


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

<x%YOJ.23052$r6p7.18939@fx41.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx41.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 476
Message-ID: <x%YOJ.23052$r6p7.18939@fx41.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 15 Feb 2022 21:07:25 -0500
X-Received-Bytes: 28069
 by: Richard Damon - Wed, 16 Feb 2022 02:07 UTC

On 2/15/22 8:17 PM, olcott wrote:
> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>
>> On 2/15/22 11:49 AM, olcott wrote:
>>> 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 ?
>>>
>>> A halt detector is the same idea as a halt decider yet a halt
>>> detector need not get every input correctly. Every input that the
>>> halt detector gets correctly is in the domain of the computable
>>> function that it implements.
>>>
>>>
>>
>> Yes, they have a copy of the Halt Detector H in them, and unless you
>> are willing to stipulate that H will not go to H.Qy when given H^ or
>> H" as an input, then you can not show that those machines are equivalent.
>
> If the simulating halt decider H cannot possibly go to H.qy on a
> specific input then any such stipulation would be redundant for this input.
>
>


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

<4qZOJ.125446$Rza5.67308@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 30
Message-ID: <4qZOJ.125446$Rza5.67308@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 15 Feb 2022 21:35:43 -0500
X-Received-Bytes: 3380
 by: Richard Damon - Wed, 16 Feb 2022 02:35 UTC

On 2/15/22 8:17 PM, olcott wrote:
>
> If the simulating halt decider H cannot possibly go to H.qy on a
> specific input then any such stipulation would be redundant for this input.
>

A second reason we need this stipulation is that I don't want to assume
you are so dumb as to just establish that there is a machine that you H
can not return a correct answer for.

Key point, what answer can H return for H <H"> <H"> that is correct.
Since H" ALWAYS Halts when the H in it returns an answer, then if we
require that H <H"> <H"> return H.Qn, which is incorrect, we have a
problem. There IS a corret answer that H can return, and that is Halting
by going to H.Qy, so any claim about contrary behavior negating the
question doesn't apply.

There is ONE consistent answer for H to return for H <H"> <H"> and be
correct, and that is Halting. If you REALLY mean to assert that a
simulating Halt decider can never return Halting for this machine, then
you are just admitting that simulating Halt Deciders can never be
correct for all machines that it is possible to build a halt decider to
decide.

Thus, even if you CAN argue that H has gotten one case that 'ordinary'
Halt Deciders couldn't get, you did it at the cost of not being able to
get rignt a case they could have.

This blows apart your arguement at the beginning, so you don't want to
begin there (or are you just conceeding that you have failed).

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

<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 15 Feb 2022 20:49:18 -0600
Date: Tue, 15 Feb 2022 20:49:16 -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
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <x%YOJ.23052$r6p7.18939@fx41.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com>
Lines: 501
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-IAmwAZfG82jo1zwKhYKQqtIvDRcn0VLI43DI7RYZ0RAUT1Y05yOUfvRwic1FEg1xUL0UDYpvdSJdaHQ!Oi2o7DgvDchjiDYWB2A7Q3BViGVrtWS+DGtp+/vf69NyLTsGDFtPFeds2OjZFTxCVlgMUCkK0281
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: 29572
 by: olcott - Wed, 16 Feb 2022 02:49 UTC

On 2/15/2022 8:07 PM, Richard Damon wrote:
> On 2/15/22 8:17 PM, olcott wrote:
>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>
>>> On 2/15/22 11:49 AM, olcott wrote:
>>>> 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 ?
>>>>
>>>> A halt detector is the same idea as a halt decider yet a halt
>>>> detector need not get every input correctly. Every input that the
>>>> halt detector gets correctly is in the domain of the computable
>>>> function that it implements.
>>>>
>>>>
>>>
>>> Yes, they have a copy of the Halt Detector H in them, and unless you
>>> are willing to stipulate that H will not go to H.Qy when given H^ or
>>> H" as an input, then you can not show that those machines are
>>> equivalent.
>>
>> If the simulating halt decider H cannot possibly go to H.qy on a
>> specific input then any such stipulation would be redundant for this
>> input.
>>
>>
>
> So why do you resist it?
>
> What is wrong with stipulating as a requirement something you 'know' to
> be true?
>
> The only reason I can see for you to object to listing that requirement.
> is that at some point you are going to want to violate that requirement.


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

<suhopv$uq5$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Date: Tue, 15 Feb 2022 20:50:37 -0600
Organization: A noiseless patient Spider
Lines: 507
Message-ID: <suhopv$uq5$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 16 Feb 2022 02:50:39 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="45428890b623cc7f2124e03c53324a41";
logging-data="31557"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1994dTbyivDC3zMmN8d56T1"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Cancel-Lock: sha1:NQcsBRQhqtbLgisD8G4inT9NQJU=
In-Reply-To: <puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com>
Content-Language: en-US
 by: olcott - Wed, 16 Feb 2022 02:50 UTC

On 2/15/2022 8:49 PM, olcott wrote:
> On 2/15/2022 8:07 PM, Richard Damon wrote:
>> On 2/15/22 8:17 PM, olcott wrote:
>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>
>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>> 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 ?
>>>>>
>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>> detector need not get every input correctly. Every input that the
>>>>> halt detector gets correctly is in the domain of the computable
>>>>> function that it implements.
>>>>>
>>>>>
>>>>
>>>> Yes, they have a copy of the Halt Detector H in them, and unless you
>>>> are willing to stipulate that H will not go to H.Qy when given H^ or
>>>> H" as an input, then you can not show that those machines are
>>>> equivalent.
>>>
>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>> specific input then any such stipulation would be redundant for this
>>> input.
>>>
>>>
>>
>> So why do you resist it?
>>
>> What is wrong with stipulating as a requirement something you 'know'
>> to be true?
>>
>> The only reason I can see for you to object to listing that
>> requirement. is that at some point you are going to want to violate
>> that requirement.
>
> Specifically because it was redundant.
> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> It does not take a genius to know that when
> embedded_H transitions to H.qn it does not transition to H.qn
embedded_H transitions to H.qn it does not transition to H.qy


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

<f_ZOJ.38447$Lbb6.13870@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <suhopv$uq5$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 535
Message-ID: <f_ZOJ.38447$Lbb6.13870@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 15 Feb 2022 22:14:18 -0500
X-Received-Bytes: 31853
 by: Richard Damon - Wed, 16 Feb 2022 03:14 UTC

On 2/15/22 9:50 PM, olcott wrote:
> On 2/15/2022 8:49 PM, olcott wrote:
>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>> On 2/15/22 8:17 PM, olcott wrote:
>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>> 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 ?
>>>>>>
>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>> detector need not get every input correctly. Every input that the
>>>>>> halt detector gets correctly is in the domain of the computable
>>>>>> function that it implements.
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, they have a copy of the Halt Detector H in them, and unless
>>>>> you are willing to stipulate that H will not go to H.Qy when given
>>>>> H^ or H" as an input, then you can not show that those machines are
>>>>> equivalent.
>>>>
>>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>>> specific input then any such stipulation would be redundant for this
>>>> input.
>>>>
>>>>
>>>
>>> So why do you resist it?
>>>
>>> What is wrong with stipulating as a requirement something you 'know'
>>> to be true?
>>>
>>> The only reason I can see for you to object to listing that
>>> requirement. is that at some point you are going to want to violate
>>> that requirement.
>>
>> Specifically because it was redundant.
>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> It does not take a genius to know that when
>> embedded_H transitions to H.qn it does not transition to H.qn
>    embedded_H transitions to H.qn it does not transition to H.qy
>


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

<JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 15 Feb 2022 21:39:08 -0600
Date: Tue, 15 Feb 2022 21:39:07 -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
](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
<f_ZOJ.38447$Lbb6.13870@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <f_ZOJ.38447$Lbb6.13870@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
Lines: 539
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lOvo+ni1xcvaUwvWUW6TD4bCzIg80WbiJ7NEiz3HWBhSlfKETvlYHmptecrdGCi2ZhqhowTwehWYZKy!N/9AY5kgWmWS/FlO6p+0rNBW3Q0IRruGg9ftTosfuRiKFUThA1psq0sYcT9yDGEzt0MXu3DX1+x6
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: 32605
 by: olcott - Wed, 16 Feb 2022 03:39 UTC

On 2/15/2022 9:14 PM, Richard Damon wrote:
> On 2/15/22 9:50 PM, olcott wrote:
>> On 2/15/2022 8:49 PM, olcott wrote:
>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>> 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 ?
>>>>>>>
>>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>>> detector need not get every input correctly. Every input that the
>>>>>>> halt detector gets correctly is in the domain of the computable
>>>>>>> function that it implements.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, they have a copy of the Halt Detector H in them, and unless
>>>>>> you are willing to stipulate that H will not go to H.Qy when given
>>>>>> H^ or H" as an input, then you can not show that those machines
>>>>>> are equivalent.
>>>>>
>>>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>>>> specific input then any such stipulation would be redundant for
>>>>> this input.
>>>>>
>>>>>
>>>>
>>>> So why do you resist it?
>>>>
>>>> What is wrong with stipulating as a requirement something you 'know'
>>>> to be true?
>>>>
>>>> The only reason I can see for you to object to listing that
>>>> requirement. is that at some point you are going to want to violate
>>>> that requirement.
>>>
>>> Specifically because it was redundant.
>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> It does not take a genius to know that when
>>> embedded_H transitions to H.qn it does not transition to H.qn
>>     embedded_H transitions to H.qn it does not transition to H.qy
>>
>
> So, are you stating as a fact that embedded_H <H^> <H^> and embedded_H
> <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>


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

<Ic%OJ.35722$41E7.34839@fx37.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx37.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
<f_ZOJ.38447$Lbb6.13870@fx45.iad>
<JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 591
Message-ID: <Ic%OJ.35722$41E7.34839@fx37.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 15 Feb 2022 23:37:59 -0500
X-Received-Bytes: 34488
 by: Richard Damon - Wed, 16 Feb 2022 04:37 UTC

On 2/15/22 10:39 PM, olcott wrote:
> On 2/15/2022 9:14 PM, Richard Damon wrote:
>> On 2/15/22 9:50 PM, olcott wrote:
>>> On 2/15/2022 8:49 PM, olcott wrote:
>>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>>> 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 ?
>>>>>>>>
>>>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>>>> detector need not get every input correctly. Every input that
>>>>>>>> the halt detector gets correctly is in the domain of the
>>>>>>>> computable function that it implements.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yes, they have a copy of the Halt Detector H in them, and unless
>>>>>>> you are willing to stipulate that H will not go to H.Qy when
>>>>>>> given H^ or H" as an input, then you can not show that those
>>>>>>> machines are equivalent.
>>>>>>
>>>>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>>>>> specific input then any such stipulation would be redundant for
>>>>>> this input.
>>>>>>
>>>>>>
>>>>>
>>>>> So why do you resist it?
>>>>>
>>>>> What is wrong with stipulating as a requirement something you
>>>>> 'know' to be true?
>>>>>
>>>>> The only reason I can see for you to object to listing that
>>>>> requirement. is that at some point you are going to want to violate
>>>>> that requirement.
>>>>
>>>> Specifically because it was redundant.
>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> It does not take a genius to know that when
>>>> embedded_H transitions to H.qn it does not transition to H.qn
>>>     embedded_H transitions to H.qn it does not transition to H.qy
>>>
>>
>> So, are you stating as a fact that embedded_H <H^> <H^> and embedded_H
>> <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>>
>
> For H to be correct then on the above specified inputs they must both go
> to H.qn.
>
>


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

<1fydncXkn7tkcpH_nZ2dnUU7-TXNnZ2d@giganews.com>

 copy mid

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

 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, 16 Feb 2022 06:37:13 -0600
Date: Wed, 16 Feb 2022 06:37:13 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.1
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
<f_ZOJ.38447$Lbb6.13870@fx45.iad>
<JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
<Ic%OJ.35722$41E7.34839@fx37.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <Ic%OJ.35722$41E7.34839@fx37.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <1fydncXkn7tkcpH_nZ2dnUU7-TXNnZ2d@giganews.com>
Lines: 573
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1ZCVKVXb2BQIV8B2FjzpzCjKu2t0PYgrwCmwC7VzLbTWh+0bUfCJutetDlB2Bm4t03Xk1Xq6y+490Y7!/tgYCt3Dg2TDtYve0/AO7st1sN/hD41p8WtkXNSEnDo8+RyIm/EoHDoEbafnYqX6dzxxdLn4Z+UE
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: 35162
 by: olcott - Wed, 16 Feb 2022 12:37 UTC

On 2/15/2022 10:37 PM, Richard Damon wrote:
> On 2/15/22 10:39 PM, olcott wrote:
>> On 2/15/2022 9:14 PM, Richard Damon wrote:
>>> On 2/15/22 9:50 PM, olcott wrote:
>>>> On 2/15/2022 8:49 PM, olcott wrote:
>>>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>>>> 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 ?
>>>>>>>>>
>>>>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>>>>> detector need not get every input correctly. Every input that
>>>>>>>>> the halt detector gets correctly is in the domain of the
>>>>>>>>> computable function that it implements.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, they have a copy of the Halt Detector H in them, and unless
>>>>>>>> you are willing to stipulate that H will not go to H.Qy when
>>>>>>>> given H^ or H" as an input, then you can not show that those
>>>>>>>> machines are equivalent.
>>>>>>>
>>>>>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>>>>>> specific input then any such stipulation would be redundant for
>>>>>>> this input.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So why do you resist it?
>>>>>>
>>>>>> What is wrong with stipulating as a requirement something you
>>>>>> 'know' to be true?
>>>>>>
>>>>>> The only reason I can see for you to object to listing that
>>>>>> requirement. is that at some point you are going to want to
>>>>>> violate that requirement.
>>>>>
>>>>> Specifically because it was redundant.
>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> It does not take a genius to know that when
>>>>> embedded_H transitions to H.qn it does not transition to H.qn
>>>>     embedded_H transitions to H.qn it does not transition to H.qy
>>>>
>>>
>>> So, are you stating as a fact that embedded_H <H^> <H^> and
>>> embedded_H <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>>>
>>
>> For H to be correct then on the above specified inputs they must both
>> go to H.qn.
>>
>>
>
> But, by DEFINITION that is the WRONG answer.
>
> DEFINITION of a Correct Halt Decider:
>
> A) H <M> w goes to H.Qy if M w Halts, and to H.Qn if M w never Halts.
I am only talking about these two:
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn


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

<rv6PJ.26589$ZmJ7.22312@fx06.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx06.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.1
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
<f_ZOJ.38447$Lbb6.13870@fx45.iad>
<JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
<Ic%OJ.35722$41E7.34839@fx37.iad>
<1fydncXkn7tkcpH_nZ2dnUU7-TXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <1fydncXkn7tkcpH_nZ2dnUU7-TXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 613
Message-ID: <rv6PJ.26589$ZmJ7.22312@fx06.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 16 Feb 2022 07:55:51 -0500
X-Received-Bytes: 37011
 by: Richard Damon - Wed, 16 Feb 2022 12:55 UTC

On 2/16/22 7:37 AM, olcott wrote:
> On 2/15/2022 10:37 PM, Richard Damon wrote:
>> On 2/15/22 10:39 PM, olcott wrote:
>>> On 2/15/2022 9:14 PM, Richard Damon wrote:
>>>> On 2/15/22 9:50 PM, olcott wrote:
>>>>> On 2/15/2022 8:49 PM, olcott wrote:
>>>>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>>>>> 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 ?
>>>>>>>>>>
>>>>>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>>>>>> detector need not get every input correctly. Every input that
>>>>>>>>>> the halt detector gets correctly is in the domain of the
>>>>>>>>>> computable function that it implements.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, they have a copy of the Halt Detector H in them, and
>>>>>>>>> unless you are willing to stipulate that H will not go to H.Qy
>>>>>>>>> when given H^ or H" as an input, then you can not show that
>>>>>>>>> those machines are equivalent.
>>>>>>>>
>>>>>>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>>>>>>> specific input then any such stipulation would be redundant for
>>>>>>>> this input.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So why do you resist it?
>>>>>>>
>>>>>>> What is wrong with stipulating as a requirement something you
>>>>>>> 'know' to be true?
>>>>>>>
>>>>>>> The only reason I can see for you to object to listing that
>>>>>>> requirement. is that at some point you are going to want to
>>>>>>> violate that requirement.
>>>>>>
>>>>>> Specifically because it was redundant.
>>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It does not take a genius to know that when
>>>>>> embedded_H transitions to H.qn it does not transition to H.qn
>>>>>     embedded_H transitions to H.qn it does not transition to H.qy
>>>>>
>>>>
>>>> So, are you stating as a fact that embedded_H <H^> <H^> and
>>>> embedded_H <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>>>>
>>>
>>> For H to be correct then on the above specified inputs they must both
>>> go to H.qn.
>>>
>>>
>>
>> But, by DEFINITION that is the WRONG answer.
>>
>> DEFINITION of a Correct Halt Decider:
>>
>> A) H <M> w goes to H.Qy if M w Halts, and to H.Qn if M w never Halts.
> I am only talking about these two:
> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Whenever any embedded_H must abort the simulation of its input to
> prevent the infinitely nested simulation of this input the entire nested
> simulation sequence specifies infinitely nested simulation. This makes a
> transition to H.qn necessarily correct in this case.
>


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

<ZJidnWwBd-E8YJH_nZ2dnUU7-YPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 16 Feb 2022 07:35:29 -0600
Date: Wed, 16 Feb 2022 07:35:29 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.1
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
<f_ZOJ.38447$Lbb6.13870@fx45.iad>
<JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
<Ic%OJ.35722$41E7.34839@fx37.iad>
<1fydncXkn7tkcpH_nZ2dnUU7-TXNnZ2d@giganews.com>
<rv6PJ.26589$ZmJ7.22312@fx06.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <rv6PJ.26589$ZmJ7.22312@fx06.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ZJidnWwBd-E8YJH_nZ2dnUU7-YPNnZ2d@giganews.com>
Lines: 608
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Tq7jhbwcfRYsBaWAMlhla96TsKxqsao/1ZntoIZj8Z36gqOQXSPtk8Eq8HMGEJERp4tRFQhOgN8kiUq!g4B670qsizlqKZD0i78XOGQmZi4pGrGMB6OqgEh4VyIOoT6veGNzFI6G3FbAfEx5rYprv2NGCEUi
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: 37787
 by: olcott - Wed, 16 Feb 2022 13:35 UTC

On 2/16/2022 6:55 AM, Richard Damon wrote:
> On 2/16/22 7:37 AM, olcott wrote:
>> On 2/15/2022 10:37 PM, Richard Damon wrote:
>>> On 2/15/22 10:39 PM, olcott wrote:
>>>> On 2/15/2022 9:14 PM, Richard Damon wrote:
>>>>> On 2/15/22 9:50 PM, olcott wrote:
>>>>>> On 2/15/2022 8:49 PM, olcott wrote:
>>>>>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>>>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>>>>>> 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 ?
>>>>>>>>>>>
>>>>>>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>>>>>>> detector need not get every input correctly. Every input that
>>>>>>>>>>> the halt detector gets correctly is in the domain of the
>>>>>>>>>>> computable function that it implements.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, they have a copy of the Halt Detector H in them, and
>>>>>>>>>> unless you are willing to stipulate that H will not go to H.Qy
>>>>>>>>>> when given H^ or H" as an input, then you can not show that
>>>>>>>>>> those machines are equivalent.
>>>>>>>>>
>>>>>>>>> If the simulating halt decider H cannot possibly go to H.qy on
>>>>>>>>> a specific input then any such stipulation would be redundant
>>>>>>>>> for this input.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So why do you resist it?
>>>>>>>>
>>>>>>>> What is wrong with stipulating as a requirement something you
>>>>>>>> 'know' to be true?
>>>>>>>>
>>>>>>>> The only reason I can see for you to object to listing that
>>>>>>>> requirement. is that at some point you are going to want to
>>>>>>>> violate that requirement.
>>>>>>>
>>>>>>> Specifically because it was redundant.
>>>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> It does not take a genius to know that when
>>>>>>> embedded_H transitions to H.qn it does not transition to H.qn
>>>>>>     embedded_H transitions to H.qn it does not transition to H.qy
>>>>>>
>>>>>
>>>>> So, are you stating as a fact that embedded_H <H^> <H^> and
>>>>> embedded_H <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>>>>>
>>>>
>>>> For H to be correct then on the above specified inputs they must
>>>> both go to H.qn.
>>>>
>>>>
>>>
>>> But, by DEFINITION that is the WRONG answer.
>>>
>>> DEFINITION of a Correct Halt Decider:
>>>
>>> A) H <M> w goes to H.Qy if M w Halts, and to H.Qn if M w never Halts.
>> I am only talking about these two:
>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Whenever any embedded_H must abort the simulation of its input to
>> prevent the infinitely nested simulation of this input the entire
>> nested simulation sequence specifies infinitely nested simulation.
>> This makes a transition to H.qn necessarily correct in this case.
>>
>
> Right, the NESTED simulation, but NOT the H^ / H" that is USING that
> embededeed_H, and it is THAT machine that defines the CORRECT answer for H.
>


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

<jcgPJ.42193$Tr18.32470@fx42.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.1
Subject: Re: Concise refutation of halting problem proofs V62 [ self-evident
](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@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> <suglil$dkp$1@dont-email.me>
<9SWOJ.25849$OT%7.13821@fx07.iad>
<2eCdnSMfgqk3zZH_nZ2dnUU7-XGdnZ2d@giganews.com>
<x%YOJ.23052$r6p7.18939@fx41.iad>
<puCdnTpdoMGz-5H_nZ2dnUU7-I_NnZ2d@giganews.com> <suhopv$uq5$1@dont-email.me>
<f_ZOJ.38447$Lbb6.13870@fx45.iad>
<JoidnTLhHMtA7JH_nZ2dnUU7-V2dnZ2d@giganews.com>
<Ic%OJ.35722$41E7.34839@fx37.iad>
<1fydncXkn7tkcpH_nZ2dnUU7-TXNnZ2d@giganews.com>
<rv6PJ.26589$ZmJ7.22312@fx06.iad>
<ZJidnWwBd-E8YJH_nZ2dnUU7-YPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ZJidnWwBd-E8YJH_nZ2dnUU7-YPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 637
Message-ID: <jcgPJ.42193$Tr18.32470@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 16 Feb 2022 18:58:07 -0500
X-Received-Bytes: 39245
 by: Richard Damon - Wed, 16 Feb 2022 23:58 UTC

On 2/16/22 8:35 AM, olcott wrote:
> On 2/16/2022 6:55 AM, Richard Damon wrote:
>> On 2/16/22 7:37 AM, olcott wrote:
>>> On 2/15/2022 10:37 PM, Richard Damon wrote:
>>>> On 2/15/22 10:39 PM, olcott wrote:
>>>>> On 2/15/2022 9:14 PM, Richard Damon wrote:
>>>>>> On 2/15/22 9:50 PM, olcott wrote:
>>>>>>> On 2/15/2022 8:49 PM, olcott wrote:
>>>>>>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>>>>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>>>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>>>>>>> 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 ?
>>>>>>>>>>>>
>>>>>>>>>>>> A halt detector is the same idea as a halt decider yet a
>>>>>>>>>>>> halt detector need not get every input correctly. Every
>>>>>>>>>>>> input that the halt detector gets correctly is in the domain
>>>>>>>>>>>> of the computable function that it implements.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, they have a copy of the Halt Detector H in them, and
>>>>>>>>>>> unless you are willing to stipulate that H will not go to
>>>>>>>>>>> H.Qy when given H^ or H" as an input, then you can not show
>>>>>>>>>>> that those machines are equivalent.
>>>>>>>>>>
>>>>>>>>>> If the simulating halt decider H cannot possibly go to H.qy on
>>>>>>>>>> a specific input then any such stipulation would be redundant
>>>>>>>>>> for this input.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So why do you resist it?
>>>>>>>>>
>>>>>>>>> What is wrong with stipulating as a requirement something you
>>>>>>>>> 'know' to be true?
>>>>>>>>>
>>>>>>>>> The only reason I can see for you to object to listing that
>>>>>>>>> requirement. is that at some point you are going to want to
>>>>>>>>> violate that requirement.
>>>>>>>>
>>>>>>>> Specifically because it was redundant.
>>>>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> It does not take a genius to know that when
>>>>>>>> embedded_H transitions to H.qn it does not transition to H.qn
>>>>>>>     embedded_H transitions to H.qn it does not transition to H.qy
>>>>>>>
>>>>>>
>>>>>> So, are you stating as a fact that embedded_H <H^> <H^> and
>>>>>> embedded_H <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>>>>>>
>>>>>
>>>>> For H to be correct then on the above specified inputs they must
>>>>> both go to H.qn.
>>>>>
>>>>>
>>>>
>>>> But, by DEFINITION that is the WRONG answer.
>>>>
>>>> DEFINITION of a Correct Halt Decider:
>>>>
>>>> A) H <M> w goes to H.Qy if M w Halts, and to H.Qn if M w never Halts.
>>> I am only talking about these two:
>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> Whenever any embedded_H must abort the simulation of its input to
>>> prevent the infinitely nested simulation of this input the entire
>>> nested simulation sequence specifies infinitely nested simulation.
>>> This makes a transition to H.qn necessarily correct in this case.
>>>
>>
>> Right, the NESTED simulation, but NOT the H^ / H" that is USING that
>> embededeed_H, and it is THAT machine that defines the CORRECT answer
>> for H.
>>
>
> That problem is that you are flat out wrong about this.
> embedded_H IS NOT REPORTING ON ITS OWN BEHAVIOR
> THUS NOT REPORTING ON Ĥ ⟨Ĥ⟩
>


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

rocksolid light 0.9.7
clearnet tor