Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Everything should be made as simple as possible, but not simpler." -- Albert Einstein


devel / comp.theory / Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

SubjectAuthor
* Concise refutation of halting problem proofs V52 [ Linz Proof ]olcott
+* Concise refutation of halting problem proofs V52 [ Linz Proof ]Richard Damon
|`* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
| `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|  `* Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]olcott
|   `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    +* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |`* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    | `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |  `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |   `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |    `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |     `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |      `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |       `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |        `* Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]Richard Damon
|    |         `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |          `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           +* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |`* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           | `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |  `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           |   `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |    `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           |     `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |      `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           |       `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |        `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           |         `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |          `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           |           `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |            `* Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]Richard Damon
|    |           |             `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |              `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           |               `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |           |                `- Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |           `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |            `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |             `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |              `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |               +* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |               |`- Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |               `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                 `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                  `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                   `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                    `* Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ](typo)Richard Damon
|    |                     `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                      `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                       `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                        `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                         `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                          `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                           `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                            `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                             `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                              `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                               `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                                `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                                 `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                                  `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                                   `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
|    |                                    `* Concise refutation of halting problem proofs V52 [ Ignorant orRichard Damon
|    |                                     `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                      `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                       `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                        `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                         `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                          `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                           `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                            `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                             `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                              `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                               `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                 `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                  `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                   `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                    `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                     `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                      `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                       `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                        `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                         `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                          `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                           `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                            `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                             `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                              `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                               `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                                `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                                 `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                                  `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                                   `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                                    `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                                     `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                                      `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                                       `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    |                                                                        `* Concise refutation of halting problem proofs V52 [ HonestRichard Damon
|    |                                                                         `* Concise refutation of halting problem proofs V52 [ Honestolcott
|    `* Concise refutation of halting problem proofs V52 [ Ignorant orolcott
`- Concise refutation of halting problem proofs V52 [ Linz Proof ]Steve

Pages:123456789101112
Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

<9k4IJ.15452$jb4.2046@fx24.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!news.neodome.net!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.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!fx24.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 996
Message-ID: <9k4IJ.15452$jb4.2046@fx24.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, 25 Jan 2022 23:43:49 -0500
X-Received-Bytes: 64357
 by: Richard Damon - Wed, 26 Jan 2022 04:43 UTC

On 1/25/22 11:36 PM, olcott wrote:
> On 1/25/2022 10:29 PM, Richard Damon wrote:
>> On 1/25/22 10:54 PM, olcott wrote:
>>> On 1/25/2022 9:42 PM, Richard Damon wrote:
>>>>
>>>> On 1/25/22 10:09 PM, olcott wrote:
>>>>> On 1/25/2022 8:00 PM, Richard Damon wrote:
>>>>>> On 1/25/22 8:11 PM, olcott wrote:
>>>>>>> On 1/25/2022 6:17 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/25/22 7:03 PM, olcott wrote:
>>>>>>>>> On 1/25/2022 5:43 PM, Richard Damon wrote:
>>>>>>>>>> On 1/25/22 9:44 AM, olcott wrote:
>>>>>>>>>>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/25/22 12:27 AM, olcott wrote:
>>>>>>>>>>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:20 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other non
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or is this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its easy to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01) 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02) 8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02) ebfe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01) 5d
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01) c3
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can do one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same method
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you serving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MORE lies by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> includes a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LYING out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that IF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no longer a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H are you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, then H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort and go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input WILL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at H^.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H -> H.Qn it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BRIGHT ENOUGH
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO GET THIS. IT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN BE VERIFIED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AS COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ON THE BASIS OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE MEANING OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can not possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state (when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then, YES, H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that due to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in H^, ANY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state anyway. YOU
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARE DUMBER THAN A
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said, I said there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H use to detect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it won't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses to decide to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG for H^ as if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ also goes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only proved that H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is non-halting for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rocks (or perhaps you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioned the word:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are much dumber than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> quite well (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nearly passed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it took
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me this long to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realize that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state is the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches a final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words do not apply to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H is determined by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to argue with a deductive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't go to H.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> making sure to always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject rather
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than directly address the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did NOT change the subject,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I pointed out an error in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your statement. You seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one assertion logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from another the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premises are always "given"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be true even if they are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise is unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> soundness we are looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point until we have mutual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguing about that which was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted unless you disagree to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the conditions that they were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the under the hypothetical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition where H can actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that the UTM will run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact needed to be correct) for H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go to H.Qn and say non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correctly simulated input' is as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by a UTM, not H (if it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other details are currently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the results of a UTM simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN determine that this condition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exists, so it would be correct,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H might not be able to decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to do so. So it may be correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it to do so, but it might not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignore that you start with an H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is defined to NOT abort, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try to use (2) to claim that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it now can abort, the H is (2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same H that the H^ in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually in the actual meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words you are using, from the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context of the problem, but I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state them because knowing you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are going to try to break that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time that you actually paid close
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the statement of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status decision on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its pure simulation of N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input. N is either the number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps that it takes for its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state or the number of steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required for H to match an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proving that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state. In this case H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulation of N steps,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but a simulation by a UTM which will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> limited N step, so it needs to prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its answer matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined, and thus N is a SPECIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number, not an 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a pattern exists in N steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correct dectect non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> come up with it or show an actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in the proof. You can't just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines its simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its correctly simulated INPUT cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothecctica Unicoprn Terretory, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means that there needs to exist a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite algroithm to determine this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, and that this result matches the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior demonstrated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitional UTM simulataion of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input), that the input will NEVER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its input can not possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the input never reached its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state must have included that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact that the copy of H inside H^ will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also do the exact same thing with the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need to be able to PROVE or actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide the exact finite algorithm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it used to detemine this fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> N steps matches an infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern embedded_H can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not embedded_H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>> this infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of N steps of its input it
>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct for it to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>> that its simulated input cannot possibly ever
>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Only if it proved that it was correct if it
>>>>>>>>>>>>>>>>>>>>>>>>>> does abort and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>>>>>>>>>>> With logical entailment the conclusion follows
>>>>>>>>>>>>>>>>>>>>>>>>> from the premise(s) by logical necessity.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly recognizes
>>>>>>>>>>>>>>>>>>>>>>>>> this infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Which makes the falicay of assuming there is a
>>>>>>>>>>>>>>>>>>>>>>>> CORRECT pattern for H to detect in H^, and that
>>>>>>>>>>>>>>>>>>>>>>>> H has the ability to detect it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are either dishonest or not bright enough to
>>>>>>>>>>>>>>>>>>>>>>> see that this is a pattern that would be very
>>>>>>>>>>>>>>>>>>>>>>> easy to match, so I guess I am finally done with
>>>>>>>>>>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> these steps would
>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which I have proven is NOT a correct pattern if H
>>>>>>>>>>>>>>>>>>>>>> actually aborts on it and goes to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes so it seems that you simply are not bright enough.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, you have proved yourself too dishonest to
>>>>>>>>>>>>>>>>>>>> actually try to prove something, but just continue
>>>>>>>>>>>>>>>>>>>> to make your claims based on your Fairy Dust powered
>>>>>>>>>>>>>>>>>>>> Unicorns.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you can't see how obvious that it is that the
>>>>>>>>>>>>>>>>>>> above pattern infinitely repeats you are not very
>>>>>>>>>>>>>>>>>>> bright.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And if you can't see that it is only infinitely
>>>>>>>>>>>>>>>>>> looping if H never aborts, then you are dumber than a
>>>>>>>>>>>>>>>>>> door nail.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is a behavior pattern that conclusively proves that
>>>>>>>>>>>>>>>>> the pure simulation of the input cannot possibly reach
>>>>>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it only proves that the pure simulation of an H^
>>>>>>>>>>>>>>>> built from an H that will NEVER abort is non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No. It really does prove that the pure simulation of the
>>>>>>>>>>>>>>> input cannot possibly reach the final state of this
>>>>>>>>>>>>>>> simulated input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How? Your trace is ignoring that there is a conditional
>>>>>>>>>>>>>> inside the copy of H that is in H^.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, it doesn't meet the requrements for the 'rule' you
>>>>>>>>>>>>>> are trying to quote, which isn't even written for the case
>>>>>>>>>>>>>> of a simulator but direct execution, and the replacement
>>>>>>>>>>>>>> of simulation with direct exection only applies to
>>>>>>>>>>>>>> UNCONDITIONAL simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You just seem to willfully be stupid to understand that a
>>>>>>>>>>>>> simulating halt decider never determines whether or not its
>>>>>>>>>>>>> input stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Instead it determines whether or not the Linz criteria can
>>>>>>>>>>>>> possibly be is met:
>>>>>>>>>>>>>
>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Lying by Double Speak again.
>>>>>>>>>>>>
>>>>>>>>>>>> By Definition, A Halt Decider decides if its Input
>>>>>>>>>>>> represents a Halting Computation, which by definition means
>>>>>>>>>>>> does the Computation the input represents Halt. This can be
>>>>>>>>>>>> equivalently defined as decides if a UTM simulating its
>>>>>>>>>>>> input will Halt or Not.
>>>>>>>>>>>>
>>>>>>>>>>>> To be correct, its answer must match the behavior of that
>>>>>>>>>>>> machine.
>>>>>>>>>>>>
>>>>>>>>>>>> If you are saying that a "Halt Decider never determines
>>>>>>>>>>>> whether or not its input stops runnning", then you are
>>>>>>>>>>>> simply not talking about Computation Theory but just your
>>>>>>>>>>>> fancy POOP, so nothing you say matters.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Since I told you this hundreds of times you are very
>>>>>>>>>>> willfully very stupid:
>>>>>>>>>>>
>>>>>>>>>>> Simulating halt deciders never determine whether or not their
>>>>>>>>>>> input stops running. Every input to a simulating halt decider
>>>>>>>>>>> always stops running either because it reached its final
>>>>>>>>>>> state or its simulation was aborted. Simulating halt deciders
>>>>>>>>>>> determine whether or not the Linz criteria can possibly be
>>>>>>>>>>> met: computation that halts … the Turing machine will halt
>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then you aren't working on the HALTING problem because that is
>>>>>>>>>> based on HALITNG of the computation being asked about.
>>>>>>>>>
>>>>>>>>> Sure I am. As I have told you hundreds of times I am using the
>>>>>>>>> Linz definition of halting.
>>>>>>>>>
>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> With the Linz definition of halting it doesn't matter whether
>>>>>>>>> or not the simulated input stops running. It only matters
>>>>>>>>> whether or not the simulating input could possibly ever reach
>>>>>>>>> its final state.
>>>>>>>>>
>>>>>>>>> The Linz definition of halting is how I link my rebuttal of the
>>>>>>>>> halting problem proofs directly to the actual halting problem
>>>>>>>>> itself.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> You DO understand that when Linz says the Turing Macine will
>>>>>>>> halt whenever it enters its final state, he is talking about the
>>>>>>>> Turing Machine being run as a totally independent machine,
>>>>>>>
>>>>>>> If he is not talking about computing mapping from the input
>>>>>>> finite strings to an accept or reject state based on the actual
>>>>>>> behavior specified by these strings then he is not talking about
>>>>>>> a decider much less a halt decider.
>>>>>>
>>>>>> The definition of Halting is not about 'Deciders'
>>>>>
>>>>>
>>>>> The definition of the halting problem is about halt decider which
>>>>> are necessarily deciders. If you get this one part wrong you get
>>>>> the whole thing wrong.
>>>>
>>>> You have it backwards. HALTING is not about Deciders, but a general
>>>> property about Compuations.
>>>>
>>> If you cannot understand that the halting problem is about a halt
>>> decider then you are far too clueless for me to waste any more time on.
>>>
>>> If a halt decider does correctly determine the halt status of its
>>> "impossible" input then the halting problem proofs have been refuted.
>>>
>>
>> The halting problem is asking IF a decider can be made to compute the
>> mapping created by the Halting Function.
>>
>> The Halting Function itself is NOT defined in terms of a decider, but
>> a mapping on behavior of actual Turing Machines.
>>
>> The proble with your proofs is that they don't show what you claim
>> they show because your decider doesn't compute the real Halting
>> Funciton because you keep using the wrong definitions of things and
>> just show that you can decide your POOP.
>
> So you are saying that Linz has the wrong definition of halting:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!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: Tue, 25 Jan 2022 22:51:51 -0600
Date: Tue, 25 Jan 2022 22:51:49 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9k4IJ.15452$jb4.2046@fx24.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com>
Lines: 1041
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jehzvePxDzZBdZfKjkgFb04csoumyaRN3difzzGR1sdSNgdiFX5rteBdbZFncnyvi17ZNHvvFJ96ggr!/7qGZ53n8pnVkVyOfNlhfwDFz6qvE2dJBCkCEiE4VxvYKJ4KT28T6VeXopGjRiKkOrnatzCSUomw
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: 67714
 by: olcott - Wed, 26 Jan 2022 04:51 UTC

On 1/25/2022 10:43 PM, Richard Damon wrote:
> On 1/25/22 11:36 PM, olcott wrote:
>> On 1/25/2022 10:29 PM, Richard Damon wrote:
>>> On 1/25/22 10:54 PM, olcott wrote:
>>>> On 1/25/2022 9:42 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/25/22 10:09 PM, olcott wrote:
>>>>>> On 1/25/2022 8:00 PM, Richard Damon wrote:
>>>>>>> On 1/25/22 8:11 PM, olcott wrote:
>>>>>>>> On 1/25/2022 6:17 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/25/22 7:03 PM, olcott wrote:
>>>>>>>>>> On 1/25/2022 5:43 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/25/22 9:44 AM, olcott wrote:
>>>>>>>>>>>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/25/22 12:27 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:25 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:20 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other non
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or is this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easy to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one case does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> method works
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you serving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it MORE lies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> includes a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of an Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LYING out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that IF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no longer a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer, which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H are you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort and go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WILL halt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H -> H.Qn it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AREN'T BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS. IT CAN
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BE VERIFIED AS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ON THE BASIS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE MEANING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (when simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by a UTM, not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just H) then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YES, H can go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that due to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in H^, ANY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BY DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said, I said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> use to detect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it won't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses to decide to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be WRONG for H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as if H goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, then H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have only proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rocks (or perhaps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioned the word:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are much dumber
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than a box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> quite well (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nearly passed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it took
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me this long to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realize that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state is the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches a final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words do not apply to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H is determined by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect to argue with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a deductive logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't go to H.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> making sure to always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject rather
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than directly address the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did NOT change the subject,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I pointed out an error in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your statement. You seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one assertion logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from another the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premises are always "given"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be true even if they are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise is unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> soundness we are looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point until we have mutual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguing about that which was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted unless you disagree to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the conditions that they were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the under the hypothetical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition where H can actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that the UTM will run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact needed to be correct) for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H to go to H.Qn and say
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correctly simulated input' is as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by a UTM, not H (if it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct other details are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation is the results of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN determine that this condition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exists, so it would be correct,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H might not be able to decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to do so. So it may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for it to do so, but it might not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ignore that you start with an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H that is defined to NOT abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but you try to use (2) to claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) must be the same H that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ in (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually in the actual meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words you are using, from the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context of the problem, but I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state them because knowing you,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are going to try to break
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time that you actually paid close
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the statement of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status decision on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its pure simulation of N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input. N is either the number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps that it takes for its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input to reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state or the number of steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required for H to match an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite behavior pattern proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulation of N steps,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but a simulation by a UTM which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> limited N step, so it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that its answer matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined, and thus N is a SPECIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number, not an 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that a pattern exists in N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps that correct dectect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be impossible, so you need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually come up with it or show an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual error in the proof. You
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines its simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothecctica Unicoprn Terretory, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means that there needs to exist a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite algroithm to determine this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, and that this result matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior demonstrated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitional UTM simulataion of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input), that the input will NEVER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its input can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the input never reached
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state must have included
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that fact that the copy of H inside
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ will also do the exact same thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with the exact same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need to be able to PROVE or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually provide the exact finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm that it used to detemine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> N steps matches an infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern embedded_H can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not embedded_H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct for it to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that that its simulated input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly ever reach its halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if it proved that it was correct if it
>>>>>>>>>>>>>>>>>>>>>>>>>>> does abort and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>>>>>>>>>>>> With logical entailment the conclusion follows
>>>>>>>>>>>>>>>>>>>>>>>>>> from the premise(s) by logical necessity.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>> this infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which makes the falicay of assuming there is a
>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT pattern for H to detect in H^, and that
>>>>>>>>>>>>>>>>>>>>>>>>> H has the ability to detect it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are either dishonest or not bright enough to
>>>>>>>>>>>>>>>>>>>>>>>> see that this is a pattern that would be very
>>>>>>>>>>>>>>>>>>>>>>>> easy to match, so I guess I am finally done with
>>>>>>>>>>>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> these steps would
>>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Which I have proven is NOT a correct pattern if H
>>>>>>>>>>>>>>>>>>>>>>> actually aborts on it and goes to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Yes so it seems that you simply are not bright
>>>>>>>>>>>>>>>>>>>>>> enough.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, you have proved yourself too dishonest to
>>>>>>>>>>>>>>>>>>>>> actually try to prove something, but just continue
>>>>>>>>>>>>>>>>>>>>> to make your claims based on your Fairy Dust
>>>>>>>>>>>>>>>>>>>>> powered Unicorns.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If you can't see how obvious that it is that the
>>>>>>>>>>>>>>>>>>>> above pattern infinitely repeats you are not very
>>>>>>>>>>>>>>>>>>>> bright.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And if you can't see that it is only infinitely
>>>>>>>>>>>>>>>>>>> looping if H never aborts, then you are dumber than a
>>>>>>>>>>>>>>>>>>> door nail.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is a behavior pattern that conclusively proves that
>>>>>>>>>>>>>>>>>> the pure simulation of the input cannot possibly reach
>>>>>>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it only proves that the pure simulation of an H^
>>>>>>>>>>>>>>>>> built from an H that will NEVER abort is non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No. It really does prove that the pure simulation of the
>>>>>>>>>>>>>>>> input cannot possibly reach the final state of this
>>>>>>>>>>>>>>>> simulated input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How? Your trace is ignoring that there is a conditional
>>>>>>>>>>>>>>> inside the copy of H that is in H^.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, it doesn't meet the requrements for the 'rule' you
>>>>>>>>>>>>>>> are trying to quote, which isn't even written for the
>>>>>>>>>>>>>>> case of a simulator but direct execution, and the
>>>>>>>>>>>>>>> replacement of simulation with direct exection only
>>>>>>>>>>>>>>> applies to UNCONDITIONAL simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You just seem to willfully be stupid to understand that a
>>>>>>>>>>>>>> simulating halt decider never determines whether or not
>>>>>>>>>>>>>> its input stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Instead it determines whether or not the Linz criteria can
>>>>>>>>>>>>>> possibly be is met:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Lying by Double Speak again.
>>>>>>>>>>>>>
>>>>>>>>>>>>> By Definition, A Halt Decider decides if its Input
>>>>>>>>>>>>> represents a Halting Computation, which by definition means
>>>>>>>>>>>>> does the Computation the input represents Halt. This can be
>>>>>>>>>>>>> equivalently defined as decides if a UTM simulating its
>>>>>>>>>>>>> input will Halt or Not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be correct, its answer must match the behavior of that
>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you are saying that a "Halt Decider never determines
>>>>>>>>>>>>> whether or not its input stops runnning", then you are
>>>>>>>>>>>>> simply not talking about Computation Theory but just your
>>>>>>>>>>>>> fancy POOP, so nothing you say matters.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Since I told you this hundreds of times you are very
>>>>>>>>>>>> willfully very stupid:
>>>>>>>>>>>>
>>>>>>>>>>>> Simulating halt deciders never determine whether or not
>>>>>>>>>>>> their input stops running. Every input to a simulating halt
>>>>>>>>>>>> decider always stops running either because it reached its
>>>>>>>>>>>> final state or its simulation was aborted. Simulating halt
>>>>>>>>>>>> deciders determine whether or not the Linz criteria can
>>>>>>>>>>>> possibly be met: computation that halts … the Turing machine
>>>>>>>>>>>> will halt whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then you aren't working on the HALTING problem because that
>>>>>>>>>>> is based on HALITNG of the computation being asked about.
>>>>>>>>>>
>>>>>>>>>> Sure I am. As I have told you hundreds of times I am using the
>>>>>>>>>> Linz definition of halting.
>>>>>>>>>>
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> With the Linz definition of halting it doesn't matter whether
>>>>>>>>>> or not the simulated input stops running. It only matters
>>>>>>>>>> whether or not the simulating input could possibly ever reach
>>>>>>>>>> its final state.
>>>>>>>>>>
>>>>>>>>>> The Linz definition of halting is how I link my rebuttal of
>>>>>>>>>> the halting problem proofs directly to the actual halting
>>>>>>>>>> problem itself.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You DO understand that when Linz says the Turing Macine will
>>>>>>>>> halt whenever it enters its final state, he is talking about
>>>>>>>>> the Turing Machine being run as a totally independent machine,
>>>>>>>>
>>>>>>>> If he is not talking about computing mapping from the input
>>>>>>>> finite strings to an accept or reject state based on the actual
>>>>>>>> behavior specified by these strings then he is not talking about
>>>>>>>> a decider much less a halt decider.
>>>>>>>
>>>>>>> The definition of Halting is not about 'Deciders'
>>>>>>
>>>>>>
>>>>>> The definition of the halting problem is about halt decider which
>>>>>> are necessarily deciders. If you get this one part wrong you get
>>>>>> the whole thing wrong.
>>>>>
>>>>> You have it backwards. HALTING is not about Deciders, but a general
>>>>> property about Compuations.
>>>>>
>>>> If you cannot understand that the halting problem is about a halt
>>>> decider then you are far too clueless for me to waste any more time on.
>>>>
>>>> If a halt decider does correctly determine the halt status of its
>>>> "impossible" input then the halting problem proofs have been refuted.
>>>>
>>>
>>> The halting problem is asking IF a decider can be made to compute the
>>> mapping created by the Halting Function.
>>>
>>> The Halting Function itself is NOT defined in terms of a decider, but
>>> a mapping on behavior of actual Turing Machines.
>>>
>>> The proble with your proofs is that they don't show what you claim
>>> they show because your decider doesn't compute the real Halting
>>> Funciton because you keep using the wrong definitions of things and
>>> just show that you can decide your POOP.
>>
>> So you are saying that Linz has the wrong definition of halting:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>>
>
> No, that is the right definition of Halting, you just seem to want to
> apply it to H doing a partial simulation of its input, and not to the
> actual processing of the Turing Machine in question.
>
_Infinite_Loop()
[00000d9a](01) 55 push ebp
[00000d9b](02) 8bec mov ebp,esp
[00000d9d](02) ebfe jmp 00000d9d
[00000d9f](01) 5d pop ebp
[00000da0](01) c3 ret
Size in bytes:(0007) [00000da0]


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

<LMaIJ.8332$V31.330@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer02.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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <fsKHJ.15868$yS2.11625@fx20.iad>
<ssnshc$jfl$1@dont-email.me> <7QKHJ.3189$rU.3101@fx34.iad>
<5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com> <EYKHJ.8824$2V.6890@fx07.iad>
<_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com> <DoLHJ.5615$QO.1124@fx29.iad>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 1118
Message-ID: <LMaIJ.8332$V31.330@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: Wed, 26 Jan 2022 07:03:55 -0500
X-Received-Bytes: 71693
 by: Richard Damon - Wed, 26 Jan 2022 12:03 UTC

On 1/25/22 11:51 PM, olcott wrote:
> On 1/25/2022 10:43 PM, Richard Damon wrote:
>> On 1/25/22 11:36 PM, olcott wrote:
>>> On 1/25/2022 10:29 PM, Richard Damon wrote:
>>>> On 1/25/22 10:54 PM, olcott wrote:
>>>>> On 1/25/2022 9:42 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/25/22 10:09 PM, olcott wrote:
>>>>>>> On 1/25/2022 8:00 PM, Richard Damon wrote:
>>>>>>>> On 1/25/22 8:11 PM, olcott wrote:
>>>>>>>>> On 1/25/2022 6:17 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/25/22 7:03 PM, olcott wrote:
>>>>>>>>>>> On 1/25/2022 5:43 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/25/22 9:44 AM, olcott wrote:
>>>>>>>>>>>>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/25/22 12:27 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:20 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion, infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or is this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easy to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0007) [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> method works
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you serving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it MORE lies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> includes a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for H^ <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LYING out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that IF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no longer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a source
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of truth
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort and go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WILL halt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AREN'T BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS. IT CAN
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BE VERIFIED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AS COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ON THE BASIS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state (when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H) then, YES,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that due to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^, ANY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BY DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said, I said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> use to detect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it won't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses to decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go to H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be WRONG
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ also
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have only proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of rocks (or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perhaps you are a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioned the word:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are much dumber
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than a box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> quite well (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nearly passed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> took me this long
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state is the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches a final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state for case when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words do not apply to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by the UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect to argue with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a deductive logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't go to H.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deceiver making sure to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always change the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rather than directly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address the point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I did NOT change the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject, I pointed out an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You seem to be unable to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one assertion logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from another the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premises are always "given"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be true even if they are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic you are claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise is unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> soundness we are looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one point until we have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguing about that which was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted unless you disagree
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the conditions that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> were accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the under the hypothetical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition where H can actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that the UTM will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> run forever, it is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (and in fact needed to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct) for H to go to H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and say non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correctly simulated input' is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as determined by a UTM, not H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct other details are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation is the results of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN determine that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition exists, so it would be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct, but H might not be able
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to decide to do so. So it may be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for it to do so, but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> might not actually be able to do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ignore that you start with an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H that is defined to NOT abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but you try to use (2) to claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) must be the same H that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ in (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually in the actual meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the words you are using, from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the context of the problem, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I state them because knowing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you, you are going to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> break that restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time that you actually paid close
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different from the statement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status decision on the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its pure simulation of N steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input. N is either the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps that it takes for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state or the number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps required for H to match an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite behavior pattern proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulation of N steps,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but a simulation by a UTM which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the limited N step, so it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that its answer matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined, and thus N is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC number, not an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that a pattern exists in N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps that correct dectect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be impossible, so you need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually come up with it or show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an actual error in the proof. You
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines its simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothecctica Unicoprn Terretory,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means that there needs to exist a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite algroithm to determine this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, and that this result matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior demonstrated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitional UTM simulataion of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input), that the input will NEVER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its input can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the input never reached
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state must have included
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that fact that the copy of H inside
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ will also do the exact same thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with the exact same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need to be able to PROVE or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually provide the exact finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm that it used to detemine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps matches an infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern embedded_H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that this simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state whether or not embedded_H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct for it to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that that its simulated input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly ever reach its halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if it proved that it was correct if it
>>>>>>>>>>>>>>>>>>>>>>>>>>>> does abort and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>>>>>>>>>>>>> With logical entailment the conclusion
>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from the premise(s) by logical
>>>>>>>>>>>>>>>>>>>>>>>>>>> necessity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes this infinitely repeating pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>> in its correct simulation of N steps of its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes the falicay of assuming there is a
>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT pattern for H to detect in H^, and
>>>>>>>>>>>>>>>>>>>>>>>>>> that H has the ability to detect it.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are either dishonest or not bright enough
>>>>>>>>>>>>>>>>>>>>>>>>> to see that this is a pattern that would be
>>>>>>>>>>>>>>>>>>>>>>>>> very easy to match, so I guess I am finally
>>>>>>>>>>>>>>>>>>>>>>>>> done with you.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> these steps would
>>>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Which I have proven is NOT a correct pattern if
>>>>>>>>>>>>>>>>>>>>>>>> H actually aborts on it and goes to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Yes so it seems that you simply are not bright
>>>>>>>>>>>>>>>>>>>>>>> enough.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, you have proved yourself too dishonest to
>>>>>>>>>>>>>>>>>>>>>> actually try to prove something, but just continue
>>>>>>>>>>>>>>>>>>>>>> to make your claims based on your Fairy Dust
>>>>>>>>>>>>>>>>>>>>>> powered Unicorns.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If you can't see how obvious that it is that the
>>>>>>>>>>>>>>>>>>>>> above pattern infinitely repeats you are not very
>>>>>>>>>>>>>>>>>>>>> bright.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And if you can't see that it is only infinitely
>>>>>>>>>>>>>>>>>>>> looping if H never aborts, then you are dumber than
>>>>>>>>>>>>>>>>>>>> a door nail.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is a behavior pattern that conclusively proves
>>>>>>>>>>>>>>>>>>> that the pure simulation of the input cannot possibly
>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it only proves that the pure simulation of an H^
>>>>>>>>>>>>>>>>>> built from an H that will NEVER abort is non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No. It really does prove that the pure simulation of
>>>>>>>>>>>>>>>>> the input cannot possibly reach the final state of this
>>>>>>>>>>>>>>>>> simulated input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> How? Your trace is ignoring that there is a conditional
>>>>>>>>>>>>>>>> inside the copy of H that is in H^.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, it doesn't meet the requrements for the 'rule' you
>>>>>>>>>>>>>>>> are trying to quote, which isn't even written for the
>>>>>>>>>>>>>>>> case of a simulator but direct execution, and the
>>>>>>>>>>>>>>>> replacement of simulation with direct exection only
>>>>>>>>>>>>>>>> applies to UNCONDITIONAL simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You just seem to willfully be stupid to understand that a
>>>>>>>>>>>>>>> simulating halt decider never determines whether or not
>>>>>>>>>>>>>>> its input stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Instead it determines whether or not the Linz criteria
>>>>>>>>>>>>>>> can possibly be is met:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Lying by Double Speak again.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> By Definition, A Halt Decider decides if its Input
>>>>>>>>>>>>>> represents a Halting Computation, which by definition
>>>>>>>>>>>>>> means does the Computation the input represents Halt. This
>>>>>>>>>>>>>> can be equivalently defined as decides if a UTM simulating
>>>>>>>>>>>>>> its input will Halt or Not.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To be correct, its answer must match the behavior of that
>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you are saying that a "Halt Decider never determines
>>>>>>>>>>>>>> whether or not its input stops runnning", then you are
>>>>>>>>>>>>>> simply not talking about Computation Theory but just your
>>>>>>>>>>>>>> fancy POOP, so nothing you say matters.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since I told you this hundreds of times you are very
>>>>>>>>>>>>> willfully very stupid:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simulating halt deciders never determine whether or not
>>>>>>>>>>>>> their input stops running. Every input to a simulating halt
>>>>>>>>>>>>> decider always stops running either because it reached its
>>>>>>>>>>>>> final state or its simulation was aborted. Simulating halt
>>>>>>>>>>>>> deciders determine whether or not the Linz criteria can
>>>>>>>>>>>>> possibly be met: computation that halts … the Turing
>>>>>>>>>>>>> machine will halt whenever it enters a final state.
>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then you aren't working on the HALTING problem because that
>>>>>>>>>>>> is based on HALITNG of the computation being asked about.
>>>>>>>>>>>
>>>>>>>>>>> Sure I am. As I have told you hundreds of times I am using
>>>>>>>>>>> the Linz definition of halting.
>>>>>>>>>>>
>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> With the Linz definition of halting it doesn't matter whether
>>>>>>>>>>> or not the simulated input stops running. It only matters
>>>>>>>>>>> whether or not the simulating input could possibly ever reach
>>>>>>>>>>> its final state.
>>>>>>>>>>>
>>>>>>>>>>> The Linz definition of halting is how I link my rebuttal of
>>>>>>>>>>> the halting problem proofs directly to the actual halting
>>>>>>>>>>> problem itself.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You DO understand that when Linz says the Turing Macine will
>>>>>>>>>> halt whenever it enters its final state, he is talking about
>>>>>>>>>> the Turing Machine being run as a totally independent machine,
>>>>>>>>>
>>>>>>>>> If he is not talking about computing mapping from the input
>>>>>>>>> finite strings to an accept or reject state based on the actual
>>>>>>>>> behavior specified by these strings then he is not talking
>>>>>>>>> about a decider much less a halt decider.
>>>>>>>>
>>>>>>>> The definition of Halting is not about 'Deciders'
>>>>>>>
>>>>>>>
>>>>>>> The definition of the halting problem is about halt decider which
>>>>>>> are necessarily deciders. If you get this one part wrong you get
>>>>>>> the whole thing wrong.
>>>>>>
>>>>>> You have it backwards. HALTING is not about Deciders, but a
>>>>>> general property about Compuations.
>>>>>>
>>>>> If you cannot understand that the halting problem is about a halt
>>>>> decider then you are far too clueless for me to waste any more time
>>>>> on.
>>>>>
>>>>> If a halt decider does correctly determine the halt status of its
>>>>> "impossible" input then the halting problem proofs have been refuted.
>>>>>
>>>>
>>>> The halting problem is asking IF a decider can be made to compute
>>>> the mapping created by the Halting Function.
>>>>
>>>> The Halting Function itself is NOT defined in terms of a decider,
>>>> but a mapping on behavior of actual Turing Machines.
>>>>
>>>> The proble with your proofs is that they don't show what you claim
>>>> they show because your decider doesn't compute the real Halting
>>>> Funciton because you keep using the wrong definitions of things and
>>>> just show that you can decide your POOP.
>>>
>>> So you are saying that Linz has the wrong definition of halting:
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>>
>>
>> No, that is the right definition of Halting, you just seem to want to
>> apply it to H doing a partial simulation of its input, and not to the
>> actual processing of the Turing Machine in question.
>>
> _Infinite_Loop()
> [00000d9a](01)  55              push ebp
> [00000d9b](02)  8bec            mov ebp,esp
> [00000d9d](02)  ebfe            jmp 00000d9d
> [00000d9f](01)  5d              pop ebp
> [00000da0](01)  c3              ret
> Size in bytes:(0007) [00000da0]
>
> You keep coming back to the idea that only an infinite simulation of an
> infinite sequence of configurations can recognize an infinite sequence
> of configurations.
>
> That is ridiculously stupid.
>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!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, 26 Jan 2022 08:39:02 -0600
Date: Wed, 26 Jan 2022 08:39:01 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <LMaIJ.8332$V31.330@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com>
Lines: 1144
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-x719BqkaYDHGm8V9DcX6hkAj08xy2H3EXB/xg70uDLyTw5m1eg6gsjWEt4ivPOikryPB3JLCuWVQKEI!cjyAqhUnkO1hH8j0RtSTZlaQhBjuba4Nlh2PJE4w5FvYh9UkgISoArdlH/cvCtf3YO7lMdoxBQR9
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: 75375
 by: olcott - Wed, 26 Jan 2022 14:39 UTC

On 1/26/2022 6:03 AM, Richard Damon wrote:
>
> On 1/25/22 11:51 PM, olcott wrote:
>> On 1/25/2022 10:43 PM, Richard Damon wrote:
>>> On 1/25/22 11:36 PM, olcott wrote:
>>>> On 1/25/2022 10:29 PM, Richard Damon wrote:
>>>>> On 1/25/22 10:54 PM, olcott wrote:
>>>>>> On 1/25/2022 9:42 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/25/22 10:09 PM, olcott wrote:
>>>>>>>> On 1/25/2022 8:00 PM, Richard Damon wrote:
>>>>>>>>> On 1/25/22 8:11 PM, olcott wrote:
>>>>>>>>>> On 1/25/2022 6:17 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/25/22 7:03 PM, olcott wrote:
>>>>>>>>>>>> On 1/25/2022 5:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/25/22 9:44 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/25/22 12:27 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:01 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022 3:20
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement, or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that knows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easy to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can do one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same method
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> serving Red
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show up in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it MORE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lies by Red
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> includes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ -> H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and for H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to that of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just LYING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> longer a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input WILL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AREN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> GET THIS. IT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN BE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> VERIFIED AS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENTIRELY ON
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE BASIS OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE MEANING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM, not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just H) then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YES, H can go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that due
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in H^, ANY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state anyway.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE DUMBER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAN A BOX OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said, I said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> use to detect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it won't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses to decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go to H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be WRONG
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ also
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have only proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of rocks (or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perhaps you are a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioned the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word: "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are much
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> quite well (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nearly passed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> took me this long
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state is the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches a final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state for case when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel words do not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply to what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect to argue
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a deductive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't go to H.Qn, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can't correctly go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deceiver making sure to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always change the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject rather than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> directly address the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I did NOT change the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject, I pointed out an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You seem to be unable to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not one assertion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another the premises are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always "given" to be true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if they are false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic you are claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise is unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> soundness we are looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logically follows from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one point until we have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you arguing about that which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was accepted unless you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they were accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the under the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothetical condition where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can actually determine that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the UTM will run forever, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct (and in fact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> needed to be correct) for H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go to H.Qn and say
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correctly simulated input' is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as determined by a UTM, not H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct other details are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation is the results of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN determine that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition exists, so it would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be correct, but H might not be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> able to decide to do so. So it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> may be correct for it to do so,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but it might not actually be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ignore that you start with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an H that is defined to NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, but you try to use (2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to claim that it now can abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the H is (2) must be the same H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the H^ in (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually in the actual meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the words you are using,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the context of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, but I state them
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because knowing you, you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> going to try to break that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time that you actually paid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> close attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different from the statement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of its pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it takes for its simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to reach its final state or the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps required for H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to match an infinite behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern proving that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state. In
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulation of N steps,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but a simulation by a UTM which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the limited N step, so it needs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove that its answer matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined, and thus N is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC number, not an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that a pattern exists in N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps that correct dectect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be impossible, so you need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually come up with it or show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an actual error in the proof. You
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines its simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothecctica Unicoprn Terretory,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means that there needs to exist a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite algroithm to determine this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case, and that this result matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior demonstrated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitional UTM simulataion of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input), that the input will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NEVER reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its input can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the input never reached
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state must have included
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that fact that the copy of H inside
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ will also do the exact same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing with the exact same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need to be able to PROVE or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually provide the exact finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm that it used to detemine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps matches an infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern embedded_H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H aborts its simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct for it to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that that its simulated input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly ever reach its halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if it proved that it was correct if it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does abort and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> With logical entailment the conclusion
>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from the premise(s) by logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes this infinitely repeating pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in its correct simulation of N steps of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes the falicay of assuming there is
>>>>>>>>>>>>>>>>>>>>>>>>>>> a CORRECT pattern for H to detect in H^, and
>>>>>>>>>>>>>>>>>>>>>>>>>>> that H has the ability to detect it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are either dishonest or not bright enough
>>>>>>>>>>>>>>>>>>>>>>>>>> to see that this is a pattern that would be
>>>>>>>>>>>>>>>>>>>>>>>>>> very easy to match, so I guess I am finally
>>>>>>>>>>>>>>>>>>>>>>>>>> done with you.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> these steps would
>>>>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which I have proven is NOT a correct pattern if
>>>>>>>>>>>>>>>>>>>>>>>>> H actually aborts on it and goes to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Yes so it seems that you simply are not bright
>>>>>>>>>>>>>>>>>>>>>>>> enough.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, you have proved yourself too dishonest to
>>>>>>>>>>>>>>>>>>>>>>> actually try to prove something, but just
>>>>>>>>>>>>>>>>>>>>>>> continue to make your claims based on your Fairy
>>>>>>>>>>>>>>>>>>>>>>> Dust powered Unicorns.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If you can't see how obvious that it is that the
>>>>>>>>>>>>>>>>>>>>>> above pattern infinitely repeats you are not very
>>>>>>>>>>>>>>>>>>>>>> bright.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And if you can't see that it is only infinitely
>>>>>>>>>>>>>>>>>>>>> looping if H never aborts, then you are dumber than
>>>>>>>>>>>>>>>>>>>>> a door nail.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is a behavior pattern that conclusively proves
>>>>>>>>>>>>>>>>>>>> that the pure simulation of the input cannot
>>>>>>>>>>>>>>>>>>>> possibly reach its final state.
>>>>>>>>>>>>>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it only proves that the pure simulation of an H^
>>>>>>>>>>>>>>>>>>> built from an H that will NEVER abort is non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No. It really does prove that the pure simulation of
>>>>>>>>>>>>>>>>>> the input cannot possibly reach the final state of
>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> How? Your trace is ignoring that there is a conditional
>>>>>>>>>>>>>>>>> inside the copy of H that is in H^.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, it doesn't meet the requrements for the 'rule'
>>>>>>>>>>>>>>>>> you are trying to quote, which isn't even written for
>>>>>>>>>>>>>>>>> the case of a simulator but direct execution, and the
>>>>>>>>>>>>>>>>> replacement of simulation with direct exection only
>>>>>>>>>>>>>>>>> applies to UNCONDITIONAL simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You just seem to willfully be stupid to understand that
>>>>>>>>>>>>>>>> a simulating halt decider never determines whether or
>>>>>>>>>>>>>>>> not its input stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Instead it determines whether or not the Linz criteria
>>>>>>>>>>>>>>>> can possibly be is met:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Lying by Double Speak again.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> By Definition, A Halt Decider decides if its Input
>>>>>>>>>>>>>>> represents a Halting Computation, which by definition
>>>>>>>>>>>>>>> means does the Computation the input represents Halt.
>>>>>>>>>>>>>>> This can be equivalently defined as decides if a UTM
>>>>>>>>>>>>>>> simulating its input will Halt or Not.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To be correct, its answer must match the behavior of that
>>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you are saying that a "Halt Decider never determines
>>>>>>>>>>>>>>> whether or not its input stops runnning", then you are
>>>>>>>>>>>>>>> simply not talking about Computation Theory but just your
>>>>>>>>>>>>>>> fancy POOP, so nothing you say matters.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since I told you this hundreds of times you are very
>>>>>>>>>>>>>> willfully very stupid:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Simulating halt deciders never determine whether or not
>>>>>>>>>>>>>> their input stops running. Every input to a simulating
>>>>>>>>>>>>>> halt decider always stops running either because it
>>>>>>>>>>>>>> reached its final state or its simulation was aborted.
>>>>>>>>>>>>>> Simulating halt deciders determine whether or not the Linz
>>>>>>>>>>>>>> criteria can possibly be met: computation that halts … the
>>>>>>>>>>>>>> Turing machine will halt whenever it enters a final state.
>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then you aren't working on the HALTING problem because that
>>>>>>>>>>>>> is based on HALITNG of the computation being asked about.
>>>>>>>>>>>>
>>>>>>>>>>>> Sure I am. As I have told you hundreds of times I am using
>>>>>>>>>>>> the Linz definition of halting.
>>>>>>>>>>>>
>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>> With the Linz definition of halting it doesn't matter
>>>>>>>>>>>> whether or not the simulated input stops running. It only
>>>>>>>>>>>> matters whether or not the simulating input could possibly
>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz definition of halting is how I link my rebuttal of
>>>>>>>>>>>> the halting problem proofs directly to the actual halting
>>>>>>>>>>>> problem itself.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You DO understand that when Linz says the Turing Macine will
>>>>>>>>>>> halt whenever it enters its final state, he is talking about
>>>>>>>>>>> the Turing Machine being run as a totally independent machine,
>>>>>>>>>>
>>>>>>>>>> If he is not talking about computing mapping from the input
>>>>>>>>>> finite strings to an accept or reject state based on the
>>>>>>>>>> actual behavior specified by these strings then he is not
>>>>>>>>>> talking about a decider much less a halt decider.
>>>>>>>>>
>>>>>>>>> The definition of Halting is not about 'Deciders'
>>>>>>>>
>>>>>>>>
>>>>>>>> The definition of the halting problem is about halt decider
>>>>>>>> which are necessarily deciders. If you get this one part wrong
>>>>>>>> you get the whole thing wrong.
>>>>>>>
>>>>>>> You have it backwards. HALTING is not about Deciders, but a
>>>>>>> general property about Compuations.
>>>>>>>
>>>>>> If you cannot understand that the halting problem is about a halt
>>>>>> decider then you are far too clueless for me to waste any more
>>>>>> time on.
>>>>>>
>>>>>> If a halt decider does correctly determine the halt status of its
>>>>>> "impossible" input then the halting problem proofs have been refuted.
>>>>>>
>>>>>
>>>>> The halting problem is asking IF a decider can be made to compute
>>>>> the mapping created by the Halting Function.
>>>>>
>>>>> The Halting Function itself is NOT defined in terms of a decider,
>>>>> but a mapping on behavior of actual Turing Machines.
>>>>>
>>>>> The proble with your proofs is that they don't show what you claim
>>>>> they show because your decider doesn't compute the real Halting
>>>>> Funciton because you keep using the wrong definitions of things and
>>>>> just show that you can decide your POOP.
>>>>
>>>> So you are saying that Linz has the wrong definition of halting:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>>
>>>
>>> No, that is the right definition of Halting, you just seem to want to
>>> apply it to H doing a partial simulation of its input, and not to the
>>> actual processing of the Turing Machine in question.
>>>
>> _Infinite_Loop()
>> [00000d9a](01)  55              push ebp
>> [00000d9b](02)  8bec            mov ebp,esp
>> [00000d9d](02)  ebfe            jmp 00000d9d
>> [00000d9f](01)  5d              pop ebp
>> [00000da0](01)  c3              ret
>> Size in bytes:(0007) [00000da0]
>>
>> You keep coming back to the idea that only an infinite simulation of
>> an infinite sequence of configurations can recognize an infinite
>> sequence of configurations.
>>
>> That is ridiculously stupid.
>>
>>
>
> You can detect SOME (not all) infinite execution in finite time due to
> patterns.
>
> There is no finite pattern in the H^ based on an H that at some point
> goest to H.Qn that correctly detects the infinite behavior.
>
> THAT is the point you miss, SOME infinite patterns are only really
> infinite when you work them out to infinitity.
>
> Part of your problem is that the traces you look at are wrong. When H
> simulates H^, it needs to trace out the actual execution path of the H
> that part of H^, not switch to tracing what it was tracing.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

<xalIJ.8632$rQ.8159@fx18.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!news.swapon.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7QKHJ.3189$rU.3101@fx34.iad>
<5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com> <EYKHJ.8824$2V.6890@fx07.iad>
<_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com> <DoLHJ.5615$QO.1124@fx29.iad>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 1210
Message-ID: <xalIJ.8632$rQ.8159@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 26 Jan 2022 18:54:05 -0500
X-Received-Bytes: 79519
 by: Richard Damon - Wed, 26 Jan 2022 23:54 UTC

On 1/26/22 9:39 AM, olcott wrote:
> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>
>> On 1/25/22 11:51 PM, olcott wrote:
>>> On 1/25/2022 10:43 PM, Richard Damon wrote:
>>>> On 1/25/22 11:36 PM, olcott wrote:
>>>>> On 1/25/2022 10:29 PM, Richard Damon wrote:
>>>>>> On 1/25/22 10:54 PM, olcott wrote:
>>>>>>> On 1/25/2022 9:42 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/25/22 10:09 PM, olcott wrote:
>>>>>>>>> On 1/25/2022 8:00 PM, Richard Damon wrote:
>>>>>>>>>> On 1/25/22 8:11 PM, olcott wrote:
>>>>>>>>>>> On 1/25/2022 6:17 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/25/22 7:03 PM, olcott wrote:
>>>>>>>>>>>>> On 1/25/2022 5:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/25/22 9:44 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/25/22 12:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:01 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1/22/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:20
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easy to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can do one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> method
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> harder
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> serving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show up in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MORE lies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Red
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> includes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a copy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just LYING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> longer a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of truth
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input WILL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AREN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> GET THIS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IT CAN BE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> VERIFIED AS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENTIRELY ON
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE BASIS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM, not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just H)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then, YES, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that due
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological self-reference'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in H^, ANY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H sees in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARE DUMBER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAN A BOX OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I said, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H use to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> detect that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> won't halt, as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H uses to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be WRONG for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ also
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have only proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of rocks (or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> perhaps you are a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notice that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never mentioned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the word: "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are much
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> quite well (you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nearly passed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> took me this long
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state is the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case when H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel words do not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply to what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect to argue
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a deductive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't go to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so H can't correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deceiver making sure to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always change the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject rather than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> directly address the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dense. I did NOT change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subject, I pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out an error in your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement. You seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be unable to comprehend
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> -> H.Qn, as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correctly simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not one assertion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another the premises are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always "given" to be true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if they are false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic you are claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise is unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> soundness we are looking at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logically follows from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one point until we have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you arguing about that which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was accepted unless you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they were accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the under the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothetical condition where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can actually determine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the UTM will run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in fact needed to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct) for H to go to H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and say non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'correctly simulated input' is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as determined by a UTM, not H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct other details are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation is the results of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H CAN determine that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition exists, so it would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be correct, but H might not be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> able to decide to do so. So it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> may be correct for it to do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so, but it might not actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> tend to ignore that you start
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with an H that is defined to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT abort, but you try to use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) to claim that it now can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, the H is (2) must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same H that the H^ in (1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually in the actual meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the words you are using,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the context of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, but I state them
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because knowing you, you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> going to try to break that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> time that you actually paid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> close attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different from the statement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of its pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it takes for its simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for H to match an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proving that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state. In
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulation of N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, but a simulation by a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the limited N step, so it needs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove that its answer matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined, and thus N is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC number, not an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that a pattern exists in N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps that correct dectect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be impossible, so you need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually come up with it or show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an actual error in the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothecctica Unicoprn Terretory,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (that means that there needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exist a finite algroithm to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine this case, and that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> result matches the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated by the definitional
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM simulataion of this input),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the input will NEVER reach it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its input can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the proof that the input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reached its final state must have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> included that fact that the copy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H inside H^ will also do the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exact same thing with the exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need to be able to PROVE or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually provide the exact finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm that it used to detemine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps matches an infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern embedded_H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H aborts its simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H never aborted its simulation, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN'T.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes this infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its correct simulation of N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of its input it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for it to report that that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its halt state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if it proved that it was correct if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does abort and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With logical entailment the conclusion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> follows from the premise(s) by logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes this infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its correct simulation of N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes the falicay of assuming there is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> a CORRECT pattern for H to detect in H^, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H has the ability to detect it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are either dishonest or not bright enough
>>>>>>>>>>>>>>>>>>>>>>>>>>> to see that this is a pattern that would be
>>>>>>>>>>>>>>>>>>>>>>>>>>> very easy to match, so I guess I am finally
>>>>>>>>>>>>>>>>>>>>>>>>>>> done with you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> these steps would
>>>>>>>>>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which I have proven is NOT a correct pattern
>>>>>>>>>>>>>>>>>>>>>>>>>> if H actually aborts on it and goes to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yes so it seems that you simply are not bright
>>>>>>>>>>>>>>>>>>>>>>>>> enough.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, you have proved yourself too dishonest to
>>>>>>>>>>>>>>>>>>>>>>>> actually try to prove something, but just
>>>>>>>>>>>>>>>>>>>>>>>> continue to make your claims based on your Fairy
>>>>>>>>>>>>>>>>>>>>>>>> Dust powered Unicorns.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If you can't see how obvious that it is that the
>>>>>>>>>>>>>>>>>>>>>>> above pattern infinitely repeats you are not very
>>>>>>>>>>>>>>>>>>>>>>> bright.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And if you can't see that it is only infinitely
>>>>>>>>>>>>>>>>>>>>>> looping if H never aborts, then you are dumber
>>>>>>>>>>>>>>>>>>>>>> than a door nail.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is a behavior pattern that conclusively proves
>>>>>>>>>>>>>>>>>>>>> that the pure simulation of the input cannot
>>>>>>>>>>>>>>>>>>>>> possibly reach its final state.
>>>>>>>>>>>>>>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, it only proves that the pure simulation of an H^
>>>>>>>>>>>>>>>>>>>> built from an H that will NEVER abort is non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No. It really does prove that the pure simulation of
>>>>>>>>>>>>>>>>>>> the input cannot possibly reach the final state of
>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> How? Your trace is ignoring that there is a
>>>>>>>>>>>>>>>>>> conditional inside the copy of H that is in H^.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, it doesn't meet the requrements for the 'rule'
>>>>>>>>>>>>>>>>>> you are trying to quote, which isn't even written for
>>>>>>>>>>>>>>>>>> the case of a simulator but direct execution, and the
>>>>>>>>>>>>>>>>>> replacement of simulation with direct exection only
>>>>>>>>>>>>>>>>>> applies to UNCONDITIONAL simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You just seem to willfully be stupid to understand that
>>>>>>>>>>>>>>>>> a simulating halt decider never determines whether or
>>>>>>>>>>>>>>>>> not its input stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Instead it determines whether or not the Linz criteria
>>>>>>>>>>>>>>>>> can possibly be is met:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Lying by Double Speak again.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By Definition, A Halt Decider decides if its Input
>>>>>>>>>>>>>>>> represents a Halting Computation, which by definition
>>>>>>>>>>>>>>>> means does the Computation the input represents Halt.
>>>>>>>>>>>>>>>> This can be equivalently defined as decides if a UTM
>>>>>>>>>>>>>>>> simulating its input will Halt or Not.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> To be correct, its answer must match the behavior of
>>>>>>>>>>>>>>>> that machine.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you are saying that a "Halt Decider never determines
>>>>>>>>>>>>>>>> whether or not its input stops runnning", then you are
>>>>>>>>>>>>>>>> simply not talking about Computation Theory but just
>>>>>>>>>>>>>>>> your fancy POOP, so nothing you say matters.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since I told you this hundreds of times you are very
>>>>>>>>>>>>>>> willfully very stupid:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Simulating halt deciders never determine whether or not
>>>>>>>>>>>>>>> their input stops running. Every input to a simulating
>>>>>>>>>>>>>>> halt decider always stops running either because it
>>>>>>>>>>>>>>> reached its final state or its simulation was aborted.
>>>>>>>>>>>>>>> Simulating halt deciders determine whether or not the
>>>>>>>>>>>>>>> Linz criteria can possibly be met: computation that halts
>>>>>>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then you aren't working on the HALTING problem because
>>>>>>>>>>>>>> that is based on HALITNG of the computation being asked
>>>>>>>>>>>>>> about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sure I am. As I have told you hundreds of times I am using
>>>>>>>>>>>>> the Linz definition of halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>> With the Linz definition of halting it doesn't matter
>>>>>>>>>>>>> whether or not the simulated input stops running. It only
>>>>>>>>>>>>> matters whether or not the simulating input could possibly
>>>>>>>>>>>>> ever reach its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz definition of halting is how I link my rebuttal of
>>>>>>>>>>>>> the halting problem proofs directly to the actual halting
>>>>>>>>>>>>> problem itself.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You DO understand that when Linz says the Turing Macine will
>>>>>>>>>>>> halt whenever it enters its final state, he is talking about
>>>>>>>>>>>> the Turing Machine being run as a totally independent machine,
>>>>>>>>>>>
>>>>>>>>>>> If he is not talking about computing mapping from the input
>>>>>>>>>>> finite strings to an accept or reject state based on the
>>>>>>>>>>> actual behavior specified by these strings then he is not
>>>>>>>>>>> talking about a decider much less a halt decider.
>>>>>>>>>>
>>>>>>>>>> The definition of Halting is not about 'Deciders'
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The definition of the halting problem is about halt decider
>>>>>>>>> which are necessarily deciders. If you get this one part wrong
>>>>>>>>> you get the whole thing wrong.
>>>>>>>>
>>>>>>>> You have it backwards. HALTING is not about Deciders, but a
>>>>>>>> general property about Compuations.
>>>>>>>>
>>>>>>> If you cannot understand that the halting problem is about a halt
>>>>>>> decider then you are far too clueless for me to waste any more
>>>>>>> time on.
>>>>>>>
>>>>>>> If a halt decider does correctly determine the halt status of its
>>>>>>> "impossible" input then the halting problem proofs have been
>>>>>>> refuted.
>>>>>>>
>>>>>>
>>>>>> The halting problem is asking IF a decider can be made to compute
>>>>>> the mapping created by the Halting Function.
>>>>>>
>>>>>> The Halting Function itself is NOT defined in terms of a decider,
>>>>>> but a mapping on behavior of actual Turing Machines.
>>>>>>
>>>>>> The proble with your proofs is that they don't show what you claim
>>>>>> they show because your decider doesn't compute the real Halting
>>>>>> Funciton because you keep using the wrong definitions of things
>>>>>> and just show that you can decide your POOP.
>>>>>
>>>>> So you are saying that Linz has the wrong definition of halting:
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>>
>>>>
>>>> No, that is the right definition of Halting, you just seem to want
>>>> to apply it to H doing a partial simulation of its input, and not to
>>>> the actual processing of the Turing Machine in question.
>>>>
>>> _Infinite_Loop()
>>> [00000d9a](01)  55              push ebp
>>> [00000d9b](02)  8bec            mov ebp,esp
>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>> [00000d9f](01)  5d              pop ebp
>>> [00000da0](01)  c3              ret
>>> Size in bytes:(0007) [00000da0]
>>>
>>> You keep coming back to the idea that only an infinite simulation of
>>> an infinite sequence of configurations can recognize an infinite
>>> sequence of configurations.
>>>
>>> That is ridiculously stupid.
>>>
>>>
>>
>> You can detect SOME (not all) infinite execution in finite time due to
>> patterns.
>>
>> There is no finite pattern in the H^ based on an H that at some point
>> goest to H.Qn that correctly detects the infinite behavior.
>>
>> THAT is the point you miss, SOME infinite patterns are only really
>> infinite when you work them out to infinitity.
>>
>> Part of your problem is that the traces you look at are wrong. When H
>> simulates H^, it needs to trace out the actual execution path of the H
>> that part of H^, not switch to tracing what it was tracing.
>>
>
> You simply lack the intellectual capacity to understand that when
> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com>

 copy mid

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

 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, 26 Jan 2022 18:09:45 -0600
Date: Wed, 26 Jan 2022 18:09:44 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com> <EYKHJ.8824$2V.6890@fx07.iad>
<_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com> <DoLHJ.5615$QO.1124@fx29.iad>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <xalIJ.8632$rQ.8159@fx18.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com>
Lines: 73
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gge0n4lt0UVK80Jq6L9VCvDURIe/aewZIyi9WEVi23JN863aBaH+BQCx1UZsM007UvtUoTVEi9gHMMq!Q2rz1QnEPN2pGaSVvAjjNaSqPlXbnu6Rxcm4TqIstmsSPKhlHfgi8einc33D0oDxh0AbSHiV8Ug6
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: 4909
 by: olcott - Thu, 27 Jan 2022 00:09 UTC

On 1/26/2022 5:54 PM, Richard Damon wrote:
> On 1/26/22 9:39 AM, olcott wrote:
>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>
>>>>>
>>>> _Infinite_Loop()
>>>> [00000d9a](01)  55              push ebp
>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>> [00000d9f](01)  5d              pop ebp
>>>> [00000da0](01)  c3              ret
>>>> Size in bytes:(0007) [00000da0]
>>>>
>>>> You keep coming back to the idea that only an infinite simulation of
>>>> an infinite sequence of configurations can recognize an infinite
>>>> sequence of configurations.
>>>>
>>>> That is ridiculously stupid.
>>>>
>>>>
>>>
>>> You can detect SOME (not all) infinite execution in finite time due
>>> to patterns.
>>>
>>> There is no finite pattern in the H^ based on an H that at some point
>>> goest to H.Qn that correctly detects the infinite behavior.
>>>
>>> THAT is the point you miss, SOME infinite patterns are only really
>>> infinite when you work them out to infinitity.
>>>
>>> Part of your problem is that the traces you look at are wrong. When H
>>> simulates H^, it needs to trace out the actual execution path of the
>>> H that part of H^, not switch to tracing what it was tracing.
>>>
>>
>> You simply lack the intellectual capacity to understand that when
>> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>>
>
> Which only happens if H NEVER aborts its simulation and thus can't give
> an answer.
>
> If H DOES abort its simulation at ANY point, then the above is NOT the
> accurate trace of the behavior of the input.
>
>
YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE

_Infinite_Loop()
[00000d9a](01) 55 push ebp
[00000d9b](02) 8bec mov ebp,esp
[00000d9d](02) ebfe jmp 00000d9d
[00000d9f](01) 5d pop ebp
[00000da0](01) c3 ret
Size in bytes:(0007) [00000da0]

You exactly same jackass point equally applies to this case:

Unless H simulates the infinite loop infinitely it is not an accurate
simulation.

--
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 V52 [ Honest Dialogue Begins ]

<eXlIJ.16438$2W.334@fx36.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx36.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <EYKHJ.8824$2V.6890@fx07.iad>
<_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com> <DoLHJ.5615$QO.1124@fx29.iad>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 82
Message-ID: <eXlIJ.16438$2W.334@fx36.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, 26 Jan 2022 19:46:02 -0500
X-Received-Bytes: 5226
 by: Richard Damon - Thu, 27 Jan 2022 00:46 UTC

On 1/26/22 7:09 PM, olcott wrote:
> On 1/26/2022 5:54 PM, Richard Damon wrote:
>> On 1/26/22 9:39 AM, olcott wrote:
>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>
>>>>>>
>>>>> _Infinite_Loop()
>>>>> [00000d9a](01)  55              push ebp
>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>> [00000d9f](01)  5d              pop ebp
>>>>> [00000da0](01)  c3              ret
>>>>> Size in bytes:(0007) [00000da0]
>>>>>
>>>>> You keep coming back to the idea that only an infinite simulation
>>>>> of an infinite sequence of configurations can recognize an infinite
>>>>> sequence of configurations.
>>>>>
>>>>> That is ridiculously stupid.
>>>>>
>>>>>
>>>>
>>>> You can detect SOME (not all) infinite execution in finite time due
>>>> to patterns.
>>>>
>>>> There is no finite pattern in the H^ based on an H that at some
>>>> point goest to H.Qn that correctly detects the infinite behavior.
>>>>
>>>> THAT is the point you miss, SOME infinite patterns are only really
>>>> infinite when you work them out to infinitity.
>>>>
>>>> Part of your problem is that the traces you look at are wrong. When
>>>> H simulates H^, it needs to trace out the actual execution path of
>>>> the H that part of H^, not switch to tracing what it was tracing.
>>>>
>>>
>>> You simply lack the intellectual capacity to understand that when
>>> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>>
>>
>> Which only happens if H NEVER aborts its simulation and thus can't
>> give an answer.
>>
>> If H DOES abort its simulation at ANY point, then the above is NOT the
>> accurate trace of the behavior of the input.
>>
>>
> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>
> _Infinite_Loop()
> [00000d9a](01)  55              push ebp
> [00000d9b](02)  8bec            mov ebp,esp
> [00000d9d](02)  ebfe            jmp 00000d9d
> [00000d9f](01)  5d              pop ebp
> [00000da0](01)  c3              ret
> Size in bytes:(0007) [00000da0]
>
> You exactly same jackass point equally applies to this case:
>
> Unless H simulates the infinite loop infinitely it is not an accurate
> simulation.
>

So, no rubbutal just red herring sushi.

The key point you miss is that if H does abort its simulation, then it
needs to take into account that the machine it is simulating will do so too.

This means that the pattern that you claim will happen infinitely, won't
but the first H in that series will abort the sequence shortly after the
point you stopped your simulation, and cause the actual behavior of the
input to be halting, as will be shown by the actual correct simulation
of that input by the UTM.

FAIL.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 26 Jan 2022 19:07:42 -0600
Date: Wed, 26 Jan 2022 19:07:41 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com> <DoLHJ.5615$QO.1124@fx29.iad>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <eXlIJ.16438$2W.334@fx36.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com>
Lines: 96
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-f9gern++zoyd7HAcVIkpgXJNBGHq8Reo7AwMWJTgamMujOeaPEnXPSwY3bAItvdQunrHU5cFgHB7EQ2!l2lyhJNQIOaOuWliZ0SSOaXhS1wvyDTagIfSSbJZFv7rUGE0jieQ93xxO0vgh0PApEi4n2TGzCAK
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: 5898
 by: olcott - Thu, 27 Jan 2022 01:07 UTC

On 1/26/2022 6:46 PM, Richard Damon wrote:
> On 1/26/22 7:09 PM, olcott wrote:
>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>> On 1/26/22 9:39 AM, olcott wrote:
>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>
>>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00000d9a](01)  55              push ebp
>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>> [00000da0](01)  c3              ret
>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>
>>>>>> You keep coming back to the idea that only an infinite simulation
>>>>>> of an infinite sequence of configurations can recognize an
>>>>>> infinite sequence of configurations.
>>>>>>
>>>>>> That is ridiculously stupid.
>>>>>>
>>>>>>
>>>>>
>>>>> You can detect SOME (not all) infinite execution in finite time due
>>>>> to patterns.
>>>>>
>>>>> There is no finite pattern in the H^ based on an H that at some
>>>>> point goest to H.Qn that correctly detects the infinite behavior.
>>>>>
>>>>> THAT is the point you miss, SOME infinite patterns are only really
>>>>> infinite when you work them out to infinitity.
>>>>>
>>>>> Part of your problem is that the traces you look at are wrong. When
>>>>> H simulates H^, it needs to trace out the actual execution path of
>>>>> the H that part of H^, not switch to tracing what it was tracing.
>>>>>
>>>>
>>>> You simply lack the intellectual capacity to understand that when
>>>> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>>
>>>
>>> Which only happens if H NEVER aborts its simulation and thus can't
>>> give an answer.
>>>
>>> If H DOES abort its simulation at ANY point, then the above is NOT
>>> the accurate trace of the behavior of the input.
>>>
>>>
>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>
>> _Infinite_Loop()
>> [00000d9a](01)  55              push ebp
>> [00000d9b](02)  8bec            mov ebp,esp
>> [00000d9d](02)  ebfe            jmp 00000d9d
>> [00000d9f](01)  5d              pop ebp
>> [00000da0](01)  c3              ret
>> Size in bytes:(0007) [00000da0]
>>
>> You exactly same jackass point equally applies to this case:
>>
>> Unless H simulates the infinite loop infinitely it is not an accurate
>> simulation.
>>
>
> So, no rubbutal just red herring sushi.
>
>
> The key point you miss is that if H does abort its simulation, then it
> needs to take into account that the machine it is simulating will do so
> too.
>

As long as H correctly determines that its simulated input cannot
possibly reach its final state in any finite number of steps it has
conclusively proved that this input never halts according to the Linz
definition:

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

The above statement is known to be true entirely on the basis of the
meaning of its words, thus disagreement is either error or dishonesty.

--
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 V52 [ error or dishonesty ]

<0wmIJ.176$XDR2.80@fx02.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx02.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <DoLHJ.5615$QO.1124@fx29.iad>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 116
Message-ID: <0wmIJ.176$XDR2.80@fx02.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, 26 Jan 2022 20:25:16 -0500
X-Received-Bytes: 6544
 by: Richard Damon - Thu, 27 Jan 2022 01:25 UTC

On 1/26/22 8:07 PM, olcott wrote:
> On 1/26/2022 6:46 PM, Richard Damon wrote:
>> On 1/26/22 7:09 PM, olcott wrote:
>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>
>>>>>>>>
>>>>>>> _Infinite_Loop()
>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>> [00000da0](01)  c3              ret
>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>
>>>>>>> You keep coming back to the idea that only an infinite simulation
>>>>>>> of an infinite sequence of configurations can recognize an
>>>>>>> infinite sequence of configurations.
>>>>>>>
>>>>>>> That is ridiculously stupid.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> You can detect SOME (not all) infinite execution in finite time
>>>>>> due to patterns.
>>>>>>
>>>>>> There is no finite pattern in the H^ based on an H that at some
>>>>>> point goest to H.Qn that correctly detects the infinite behavior.
>>>>>>
>>>>>> THAT is the point you miss, SOME infinite patterns are only really
>>>>>> infinite when you work them out to infinitity.
>>>>>>
>>>>>> Part of your problem is that the traces you look at are wrong.
>>>>>> When H simulates H^, it needs to trace out the actual execution
>>>>>> path of the H that part of H^, not switch to tracing what it was
>>>>>> tracing.
>>>>>>
>>>>>
>>>>> You simply lack the intellectual capacity to understand that when
>>>>> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>>
>>>>
>>>> Which only happens if H NEVER aborts its simulation and thus can't
>>>> give an answer.
>>>>
>>>> If H DOES abort its simulation at ANY point, then the above is NOT
>>>> the accurate trace of the behavior of the input.
>>>>
>>>>
>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>
>>> _Infinite_Loop()
>>> [00000d9a](01)  55              push ebp
>>> [00000d9b](02)  8bec            mov ebp,esp
>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>> [00000d9f](01)  5d              pop ebp
>>> [00000da0](01)  c3              ret
>>> Size in bytes:(0007) [00000da0]
>>>
>>> You exactly same jackass point equally applies to this case:
>>>
>>> Unless H simulates the infinite loop infinitely it is not an accurate
>>> simulation.
>>>
>>
>> So, no rubbutal just red herring sushi.
>>
>>
>> The key point you miss is that if H does abort its simulation, then it
>> needs to take into account that the machine it is simulating will do
>> so too.
>>
>
> As long as H correctly determines that its simulated input cannot
> possibly reach its final state in any finite number of steps it has
> conclusively proved that this input never halts according to the Linz
> definition:

But it needs to prove that the UTM of its input never halts, and for H^,
that means even if the H insisde H^ goes to H.Qn which means that H^
goes to H^.Qn, which of course Halts.

So, H can only correctly determine that its simulated input cannot
possibly reach its final state if H can't go to H.Qn, so any H that
does, didn't actually prove what it needed.

This means that any H that waits until it can actually prove this, will
simulate for an infinite number of steps, and thus fail to answer in a
finite number of steps, and any H that stops earlier failed to prove
what it needed and answers incorrectly.

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

Which H^ does if H goes to H.Qn

>
> The above statement is known to be true entirely on the basis of the
> meaning of its words, thus disagreement is either error or dishonesty.
>

Right, and by the meaning of the words, H^ HALTS if H goes to H.Qn,
because the meaning of the words includes that the entering of the final
state is by the ACTUAL machine, it doesn't matter if H does see it.

FAIL.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>

 copy mid

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

 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, 26 Jan 2022 20:18:22 -0600
Date: Wed, 26 Jan 2022 20:18:21 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <0wmIJ.176$XDR2.80@fx02.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
Lines: 144
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1Qqitc2wjSroxFNsocmKf6Tq+yeo3Fcqrv9zAmrCjPYSVxhqd+OSiolMAQN52ym7KtIitSu19g22jK8!610jF5jmqwTCRQrz5jpogN+/yximW6OxGAycfQwLusWS1wUufkjbW5+IaIIJ8H7l4F+uOz+TXbq7
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: 8145
 by: olcott - Thu, 27 Jan 2022 02:18 UTC

On 1/26/2022 7:25 PM, Richard Damon wrote:
> On 1/26/22 8:07 PM, olcott wrote:
>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>> On 1/26/22 7:09 PM, olcott wrote:
>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>
>>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>
>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>
>>>>>>>> That is ridiculously stupid.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> You can detect SOME (not all) infinite execution in finite time
>>>>>>> due to patterns.
>>>>>>>
>>>>>>> There is no finite pattern in the H^ based on an H that at some
>>>>>>> point goest to H.Qn that correctly detects the infinite behavior.
>>>>>>>
>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>
>>>>>>> Part of your problem is that the traces you look at are wrong.
>>>>>>> When H simulates H^, it needs to trace out the actual execution
>>>>>>> path of the H that part of H^, not switch to tracing what it was
>>>>>>> tracing.
>>>>>>>
>>>>>>
>>>>>> You simply lack the intellectual capacity to understand that when
>>>>>> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>>
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>>
>>>>>
>>>>> Which only happens if H NEVER aborts its simulation and thus can't
>>>>> give an answer.
>>>>>
>>>>> If H DOES abort its simulation at ANY point, then the above is NOT
>>>>> the accurate trace of the behavior of the input.
>>>>>
>>>>>
>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>
>>>> _Infinite_Loop()
>>>> [00000d9a](01)  55              push ebp
>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>> [00000d9f](01)  5d              pop ebp
>>>> [00000da0](01)  c3              ret
>>>> Size in bytes:(0007) [00000da0]
>>>>
>>>> You exactly same jackass point equally applies to this case:
>>>>
>>>> Unless H simulates the infinite loop infinitely it is not an
>>>> accurate simulation.
>>>>
>>>
>>> So, no rubbutal just red herring sushi.
>>>
>>>
>>> The key point you miss is that if H does abort its simulation, then
>>> it needs to take into account that the machine it is simulating will
>>> do so too.
>>>
>>
>> As long as H correctly determines that its simulated input cannot
>> possibly reach its final state in any finite number of steps it has
>> conclusively proved that this input never halts according to the Linz
>> definition:
>
>
> But it needs to prove that the UTM of its input never halts, and for H^,
> that means even if the H insisde H^ goes to H.Qn which means that H^
> goes to H^.Qn, which of course Halts.
>

As soon as embedded_H (not H) determines that its simulated input ⟨Ĥ⟩
applied to ⟨Ĥ⟩ cannot possibly reach its final state in any finite
number of steps it terminates this simulation immediately stopping every
element of the entire chain of nested simulations.

Then embedded_H transitions to Ĥ.qn which causes the original Ĥ applied
to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to embedded_H and
a decider is only accountable for computing the mapping from its actual
inputs to an accept or reject state it makes no difference that Ĥ
applied to ⟨Ĥ⟩ halts.

It is like you put a guard on the front door that is supposed to report
anyone coming in the front door (the actual inputs). Then someone comes
in the back door (non inputs) and the guard does not report this. Since
the guard is only supposed to report people coming in the front door it
is incorrect to say that the guard made a mistake by not reporting
people that came in the back door.

> So, H can only correctly determine that its simulated input cannot
> possibly reach its final state if H can't go to H.Qn, so any H that
> does, didn't actually prove what it needed.
>
> This means that any H that waits until it can actually prove this, will
> simulate for an infinite number of steps, and thus fail to answer in a
> finite number of steps, and any H that stops earlier failed to prove
> what it needed and answers incorrectly.
>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
> Which H^ does if H goes to H.Qn
>
>>
>> The above statement is known to be true entirely on the basis of the
>> meaning of its words, thus disagreement is either error or dishonesty.
>>
>
> Right, and by the meaning of the words, H^ HALTS if H goes to H.Qn,
> because the meaning of the words includes that the entering of the final
> state is by the ACTUAL machine, it doesn't matter if H does see it.
>
> FAIL.
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<csnIJ.19295$OU.5598@fx22.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx22.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 177
Message-ID: <csnIJ.19295$OU.5598@fx22.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, 26 Jan 2022 21:29:28 -0500
X-Received-Bytes: 9442
 by: Richard Damon - Thu, 27 Jan 2022 02:29 UTC

On 1/26/22 9:18 PM, olcott wrote:
> On 1/26/2022 7:25 PM, Richard Damon wrote:
>> On 1/26/22 8:07 PM, olcott wrote:
>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>>>
>>>>>>>>> _Infinite_Loop()
>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>
>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>
>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> You can detect SOME (not all) infinite execution in finite time
>>>>>>>> due to patterns.
>>>>>>>>
>>>>>>>> There is no finite pattern in the H^ based on an H that at some
>>>>>>>> point goest to H.Qn that correctly detects the infinite behavior.
>>>>>>>>
>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>
>>>>>>>> Part of your problem is that the traces you look at are wrong.
>>>>>>>> When H simulates H^, it needs to trace out the actual execution
>>>>>>>> path of the H that part of H^, not switch to tracing what it was
>>>>>>>> tracing.
>>>>>>>>
>>>>>>>
>>>>>>> You simply lack the intellectual capacity to understand that when
>>>>>>> embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>>>
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Which only happens if H NEVER aborts its simulation and thus can't
>>>>>> give an answer.
>>>>>>
>>>>>> If H DOES abort its simulation at ANY point, then the above is NOT
>>>>>> the accurate trace of the behavior of the input.
>>>>>>
>>>>>>
>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>
>>>>> _Infinite_Loop()
>>>>> [00000d9a](01)  55              push ebp
>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>> [00000d9f](01)  5d              pop ebp
>>>>> [00000da0](01)  c3              ret
>>>>> Size in bytes:(0007) [00000da0]
>>>>>
>>>>> You exactly same jackass point equally applies to this case:
>>>>>
>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>> accurate simulation.
>>>>>
>>>>
>>>> So, no rubbutal just red herring sushi.
>>>>
>>>>
>>>> The key point you miss is that if H does abort its simulation, then
>>>> it needs to take into account that the machine it is simulating will
>>>> do so too.
>>>>
>>>
>>> As long as H correctly determines that its simulated input cannot
>>> possibly reach its final state in any finite number of steps it has
>>> conclusively proved that this input never halts according to the Linz
>>> definition:
>>
>>
>> But it needs to prove that the UTM of its input never halts, and for
>> H^, that means even if the H insisde H^ goes to H.Qn which means that
>> H^ goes to H^.Qn, which of course Halts.
>>
>
> As soon as embedded_H (not H) determines that its simulated input ⟨Ĥ⟩
> applied to ⟨Ĥ⟩ cannot possibly reach its final state in any finite
> number of steps it terminates this simulation immediately stopping every
> element of the entire chain of nested simulations.
>

If you are claiming that embedded_H and H behave differently then you
have been lying that you built H^ by the instruction of Linz, as the
copy of H inside H^ is IDENTICAL (except what happens AFTER getting to H.Qy)

Now, IF H could make that proof, then it would be correct to go to H.Qn,
but it would need to take into account that H^ halts if its copy of H
goes to H.Qn, so this is NEVER possible.

FAIL

> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ applied
> to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to embedded_H and
> a decider is only accountable for computing the mapping from its actual
> inputs to an accept or reject state it makes no difference that Ĥ
> applied to ⟨Ĥ⟩ halts.

Thus you have admitted to LYING about working on the Halting problem as
if you were the embedded_H would be the same algorithm as H, and the
requirement on H was that is IS accoutable for the machine its input
represents, so H <H^> <H^> NEEDS to be accountable for the behavior or
H^ applied to <H^>, so by your claim you have admitted to LYING about
working on the Halting Problem.

Remember, the definition of the correct behavior of H, and thus
embedded_H if H^ was built correctly is that H <H^> <H^> will go to
either H.Qy or H.Qn based on whether H^ applied to <H^> will halt.

>
> It is like you put a guard on the front door that is supposed to report
> anyone coming in the front door (the actual inputs). Then someone comes
> in the back door (non inputs) and the guard does not report this. Since
> the guard is only supposed to report people coming in the front door it
> is incorrect to say that the guard made a mistake by not reporting
> people that came in the back door.

RED HERING.

the input <H^> <H^> represents H^ applied to <HT^> if you are working on
the Halting problem. the it is the front door and you guard appearent is
making up a story to get around the fact that it failed.

Since it is clear that you are not following the requirements of the
Halting problem, you 'proof' has no meaning on it, and you claim to be a
counter to Linz is impossible as your machines don't match the
requirements of that proof.

FAIL.

>
>> So, H can only correctly determine that its simulated input cannot
>> possibly reach its final state if H can't go to H.Qn, so any H that
>> does, didn't actually prove what it needed.
>>
>> This means that any H that waits until it can actually prove this,
>> will simulate for an infinite number of steps, and thus fail to answer
>> in a finite number of steps, and any H that stops earlier failed to
>> prove what it needed and answers incorrectly.
>>
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>
>> Which H^ does if H goes to H.Qn
>>
>>>
>>> The above statement is known to be true entirely on the basis of the
>>> meaning of its words, thus disagreement is either error or dishonesty.
>>>
>>
>> Right, and by the meaning of the words, H^ HALTS if H goes to H.Qn,
>> because the meaning of the words includes that the entering of the
>> final state is by the ACTUAL machine, it doesn't matter if H does see it.
>>
>> FAIL.
>>
>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

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

 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, 26 Jan 2022 20:42:19 -0600
Date: Wed, 26 Jan 2022 20:42:18 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <csnIJ.19295$OU.5598@fx22.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 135
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YVjozdvSDwUd+bWx5TbI7NPOA784e3cjWqj9WbpWBQg4d7DRxT6uepvXGmByJxYgJIfnl3CjpUmce84!sK8NoZ+EqrCk5QZI5zQ+HshtKc1hY4iswObkQIBGL1ntzbmNRqO2s5Qy+6OERGzFrxGW9Q00PlPO
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: 8010
 by: olcott - Thu, 27 Jan 2022 02:42 UTC

On 1/26/2022 8:29 PM, Richard Damon wrote:
> On 1/26/22 9:18 PM, olcott wrote:
>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>> On 1/26/22 8:07 PM, olcott wrote:
>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>
>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>
>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You can detect SOME (not all) infinite execution in finite time
>>>>>>>>> due to patterns.
>>>>>>>>>
>>>>>>>>> There is no finite pattern in the H^ based on an H that at some
>>>>>>>>> point goest to H.Qn that correctly detects the infinite behavior.
>>>>>>>>>
>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>
>>>>>>>>> Part of your problem is that the traces you look at are wrong.
>>>>>>>>> When H simulates H^, it needs to trace out the actual execution
>>>>>>>>> path of the H that part of H^, not switch to tracing what it
>>>>>>>>> was tracing.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>>>>
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>> can't give an answer.
>>>>>>>
>>>>>>> If H DOES abort its simulation at ANY point, then the above is
>>>>>>> NOT the accurate trace of the behavior of the input.
>>>>>>>
>>>>>>>
>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00000d9a](01)  55              push ebp
>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>> [00000da0](01)  c3              ret
>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>
>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>
>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>> accurate simulation.
>>>>>>
>>>>>
>>>>> So, no rubbutal just red herring sushi.
>>>>>
>>>>>
>>>>> The key point you miss is that if H does abort its simulation, then
>>>>> it needs to take into account that the machine it is simulating
>>>>> will do so too.
>>>>>
>>>>
>>>> As long as H correctly determines that its simulated input cannot
>>>> possibly reach its final state in any finite number of steps it has
>>>> conclusively proved that this input never halts according to the
>>>> Linz definition:
>>>
>>>
>>> But it needs to prove that the UTM of its input never halts, and for
>>> H^, that means even if the H insisde H^ goes to H.Qn which means that
>>> H^ goes to H^.Qn, which of course Halts.
>>>
>>
>> As soon as embedded_H (not H) determines that its simulated input ⟨Ĥ⟩
>> applied to ⟨Ĥ⟩ cannot possibly reach its final state in any finite
>> number of steps it terminates this simulation immediately stopping
>> every element of the entire chain of nested simulations.
>>
>
> If you are claiming that embedded_H and H behave differently then you
> have been lying that you built H^ by the instruction of Linz, as the
> copy of H inside H^ is IDENTICAL (except what happens AFTER getting to
> H.Qy)
>
> Now, IF H could make that proof, then it would be correct to go to H.Qn,
> but it would need to take into account that H^ halts if its copy of H
> goes to H.Qn, so this is NEVER possible.
>
> FAIL
>
>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>> embedded_H and a decider is only accountable for computing the mapping
>> from its actual inputs to an accept or reject state it makes no
>> difference that Ĥ applied to ⟨Ĥ⟩ halts.
>
> Thus you have admitted to LYING about working on the Halting problem as
> if you were the embedded_H would be the same algorithm as H, and the
> requirement on H was that is IS accoutable for the machine its input
> represents,

You are simply too freaking stupid to understand that deciders thus halt
deciders are only accountable for computing the mapping from their
actual inputs (nothing else in the whole freaking universe besides their
actual inputs) to an accept or reject state.

An actual computer scientist would know this.

--
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 V52 [ error or dishonesty ]

<N9oIJ.384$N31.159@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 167
Message-ID: <N9oIJ.384$N31.159@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: Wed, 26 Jan 2022 22:18:05 -0500
X-Received-Bytes: 9449
 by: Richard Damon - Thu, 27 Jan 2022 03:18 UTC

On 1/26/22 9:42 PM, olcott wrote:
> On 1/26/2022 8:29 PM, Richard Damon wrote:
>> On 1/26/22 9:18 PM, olcott wrote:
>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>
>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>
>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>> time due to patterns.
>>>>>>>>>>
>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>> some point goest to H.Qn that correctly detects the infinite
>>>>>>>>>> behavior.
>>>>>>>>>>
>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>>
>>>>>>>>>> Part of your problem is that the traces you look at are wrong.
>>>>>>>>>> When H simulates H^, it needs to trace out the actual
>>>>>>>>>> execution path of the H that part of H^, not switch to tracing
>>>>>>>>>> what it was tracing.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>>>>>
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>> can't give an answer.
>>>>>>>>
>>>>>>>> If H DOES abort its simulation at ANY point, then the above is
>>>>>>>> NOT the accurate trace of the behavior of the input.
>>>>>>>>
>>>>>>>>
>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>
>>>>>>> _Infinite_Loop()
>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>> [00000da0](01)  c3              ret
>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>
>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>
>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>> accurate simulation.
>>>>>>>
>>>>>>
>>>>>> So, no rubbutal just red herring sushi.
>>>>>>
>>>>>>
>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>> then it needs to take into account that the machine it is
>>>>>> simulating will do so too.
>>>>>>
>>>>>
>>>>> As long as H correctly determines that its simulated input cannot
>>>>> possibly reach its final state in any finite number of steps it has
>>>>> conclusively proved that this input never halts according to the
>>>>> Linz definition:
>>>>
>>>>
>>>> But it needs to prove that the UTM of its input never halts, and for
>>>> H^, that means even if the H insisde H^ goes to H.Qn which means
>>>> that H^ goes to H^.Qn, which of course Halts.
>>>>
>>>
>>> As soon as embedded_H (not H) determines that its simulated input ⟨Ĥ⟩
>>> applied to ⟨Ĥ⟩ cannot possibly reach its final state in any finite
>>> number of steps it terminates this simulation immediately stopping
>>> every element of the entire chain of nested simulations.
>>>
>>
>> If you are claiming that embedded_H and H behave differently then you
>> have been lying that you built H^ by the instruction of Linz, as the
>> copy of H inside H^ is IDENTICAL (except what happens AFTER getting to
>> H.Qy)
>>
>> Now, IF H could make that proof, then it would be correct to go to
>> H.Qn, but it would need to take into account that H^ halts if its copy
>> of H goes to H.Qn, so this is NEVER possible.
>>
>> FAIL
>>
>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>> embedded_H and a decider is only accountable for computing the
>>> mapping from its actual inputs to an accept or reject state it makes
>>> no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>
>> Thus you have admitted to LYING about working on the Halting problem
>> as if you were the embedded_H would be the same algorithm as H, and
>> the requirement on H was that is IS accoutable for the machine its
>> input represents,
>
> You are simply too freaking stupid to understand that deciders thus halt
> deciders are only accountable for computing the mapping from their
> actual inputs (nothing else in the whole freaking universe besides their
> actual inputs) to an accept or reject state.
>
> An actual computer scientist would know this.
>

It seems you don't understand the difference between capabilities and
requirements.

H is only CAPABLE of deciding based on what it can do. It can only
computate a mapping based on what it actually can do.

It is REQUIRED to meet its requirements, which is to decide on the
behavior of what its input would do if given to a UTM.

H(x,y) is REQUIRED (to be correct and satisfy what it needs to be) to go
to H.Qy if UTM(x,y) will Halt, and to H.Qn if it will NEVER halt. This
includes the case where x contains a copy of the algoritm of H, and the
UTM will see that H do exactly what this H will do with that input.

Yes, H is not CAPABLE of naively doing that, so to meet its requirement
it needs to try to be more intelegent. (Which you don't seem to be able
to do).

The key is that it is shown that since if H(x,x) -> H.Qn, then we can
show that H^(x) will also go to H^.Qn, and thus if x = <H^>, since it is
DEFINED that H(<H^>,<H^) means H is to decide on H^ applied to <H^>
which is the same behavior as UTM(<H^>.<H^>) that if H(<H^>.<H^>) ->
H.Qn then H^(<H^>) will also go to H^.Qn, and Halt. Thus H gave the
wrong answer for the behavior of its input.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>

 copy mid

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

 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, 26 Jan 2022 22:00:00 -0600
Date: Wed, 26 Jan 2022 21:59:59 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <N9oIJ.384$N31.159@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
Lines: 157
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-OGH+nNh+R0CFdqezZIlxRKasDJIm+/qnHK0cp41Pkd4pbTp4+kzZHW1pQqjAzsqNWElNUZRxuCodQG4!SyCI84szFbLJaKqyPgvPT7GSn6WXkkySRmi4t3Tv24Aw5ha37bbfTGzVNGRCB62C+/5kzbYZFmIj
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: 8977
 by: olcott - Thu, 27 Jan 2022 03:59 UTC

On 1/26/2022 9:18 PM, Richard Damon wrote:
> On 1/26/22 9:42 PM, olcott wrote:
>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>> On 1/26/22 9:18 PM, olcott wrote:
>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>
>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>
>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>>> time due to patterns.
>>>>>>>>>>>
>>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>>> some point goest to H.Qn that correctly detects the infinite
>>>>>>>>>>> behavior.
>>>>>>>>>>>
>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>>>
>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the actual
>>>>>>>>>>> execution path of the H that part of H^, not switch to
>>>>>>>>>>> tracing what it was tracing.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>>>>>>
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>>> can't give an answer.
>>>>>>>>>
>>>>>>>>> If H DOES abort its simulation at ANY point, then the above is
>>>>>>>>> NOT the accurate trace of the behavior of the input.
>>>>>>>>>
>>>>>>>>>
>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>
>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>
>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>> accurate simulation.
>>>>>>>>
>>>>>>>
>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>
>>>>>>>
>>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>>> then it needs to take into account that the machine it is
>>>>>>> simulating will do so too.
>>>>>>>
>>>>>>
>>>>>> As long as H correctly determines that its simulated input cannot
>>>>>> possibly reach its final state in any finite number of steps it
>>>>>> has conclusively proved that this input never halts according to
>>>>>> the Linz definition:
>>>>>
>>>>>
>>>>> But it needs to prove that the UTM of its input never halts, and
>>>>> for H^, that means even if the H insisde H^ goes to H.Qn which
>>>>> means that H^ goes to H^.Qn, which of course Halts.
>>>>>
>>>>
>>>> As soon as embedded_H (not H) determines that its simulated input
>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state in any
>>>> finite number of steps it terminates this simulation immediately
>>>> stopping every element of the entire chain of nested simulations.
>>>>
>>>
>>> If you are claiming that embedded_H and H behave differently then you
>>> have been lying that you built H^ by the instruction of Linz, as the
>>> copy of H inside H^ is IDENTICAL (except what happens AFTER getting
>>> to H.Qy)
>>>
>>> Now, IF H could make that proof, then it would be correct to go to
>>> H.Qn, but it would need to take into account that H^ halts if its
>>> copy of H goes to H.Qn, so this is NEVER possible.
>>>
>>> FAIL
>>>
>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>>> embedded_H and a decider is only accountable for computing the
>>>> mapping from its actual inputs to an accept or reject state it makes
>>>> no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>
>>> Thus you have admitted to LYING about working on the Halting problem
>>> as if you were the embedded_H would be the same algorithm as H, and
>>> the requirement on H was that is IS accoutable for the machine its
>>> input represents,
>>
>> You are simply too freaking stupid to understand that deciders thus
>> halt deciders are only accountable for computing the mapping from
>> their actual inputs (nothing else in the whole freaking universe
>> besides their actual inputs) to an accept or reject state.
>>
>> An actual computer scientist would know this.
>>
>
> It seems you don't understand the difference between capabilities and
> requirements.
>
> H is only CAPABLE of deciding based on what it can do. It can only
> computate a mapping based on what it actually can do.
>
> It is REQUIRED to meet its requirements, which is to decide on the
> behavior of what its input would do if given to a UTM.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<JToIJ.296644$1d1.101887@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 168
Message-ID: <JToIJ.296644$1d1.101887@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 26 Jan 2022 23:07:05 -0500
X-Received-Bytes: 9317
 by: Richard Damon - Thu, 27 Jan 2022 04:07 UTC

On 1/26/22 10:59 PM, olcott wrote:
> On 1/26/2022 9:18 PM, Richard Damon wrote:
>> On 1/26/22 9:42 PM, olcott wrote:
>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>
>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>>>> time due to patterns.
>>>>>>>>>>>>
>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>>>> some point goest to H.Qn that correctly detects the infinite
>>>>>>>>>>>> behavior.
>>>>>>>>>>>>
>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>>>>
>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the actual
>>>>>>>>>>>> execution path of the H that part of H^, not switch to
>>>>>>>>>>>> tracing what it was tracing.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the
>>>>>>>>>>> pattern:
>>>>>>>>>>>
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>>>> can't give an answer.
>>>>>>>>>>
>>>>>>>>>> If H DOES abort its simulation at ANY point, then the above is
>>>>>>>>>> NOT the accurate trace of the behavior of the input.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>
>>>>>>>>> _Infinite_Loop()
>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>
>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>
>>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>>> accurate simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>
>>>>>>>>
>>>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>>>> then it needs to take into account that the machine it is
>>>>>>>> simulating will do so too.
>>>>>>>>
>>>>>>>
>>>>>>> As long as H correctly determines that its simulated input cannot
>>>>>>> possibly reach its final state in any finite number of steps it
>>>>>>> has conclusively proved that this input never halts according to
>>>>>>> the Linz definition:
>>>>>>
>>>>>>
>>>>>> But it needs to prove that the UTM of its input never halts, and
>>>>>> for H^, that means even if the H insisde H^ goes to H.Qn which
>>>>>> means that H^ goes to H^.Qn, which of course Halts.
>>>>>>
>>>>>
>>>>> As soon as embedded_H (not H) determines that its simulated input
>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state in any
>>>>> finite number of steps it terminates this simulation immediately
>>>>> stopping every element of the entire chain of nested simulations.
>>>>>
>>>>
>>>> If you are claiming that embedded_H and H behave differently then
>>>> you have been lying that you built H^ by the instruction of Linz, as
>>>> the copy of H inside H^ is IDENTICAL (except what happens AFTER
>>>> getting to H.Qy)
>>>>
>>>> Now, IF H could make that proof, then it would be correct to go to
>>>> H.Qn, but it would need to take into account that H^ halts if its
>>>> copy of H goes to H.Qn, so this is NEVER possible.
>>>>
>>>> FAIL
>>>>
>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>>>> embedded_H and a decider is only accountable for computing the
>>>>> mapping from its actual inputs to an accept or reject state it
>>>>> makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>
>>>> Thus you have admitted to LYING about working on the Halting problem
>>>> as if you were the embedded_H would be the same algorithm as H, and
>>>> the requirement on H was that is IS accoutable for the machine its
>>>> input represents,
>>>
>>> You are simply too freaking stupid to understand that deciders thus
>>> halt deciders are only accountable for computing the mapping from
>>> their actual inputs (nothing else in the whole freaking universe
>>> besides their actual inputs) to an accept or reject state.
>>>
>>> An actual computer scientist would know this.
>>>
>>
>> It seems you don't understand the difference between capabilities and
>> requirements.
>>
>> H is only CAPABLE of deciding based on what it can do. It can only
>> computate a mapping based on what it actually can do.
>>
>> It is REQUIRED to meet its requirements, which is to decide on the
>> behavior of what its input would do if given to a UTM.
>>
>
> embedded_H must only determine whether or not is simulated input can
> ever reach its final state in any finite number of steps.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>

 copy mid

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

 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!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: Wed, 26 Jan 2022 22:38:01 -0600
Date: Wed, 26 Jan 2022 22:37:59 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <JToIJ.296644$1d1.101887@fx99.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
Lines: 184
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4f9ZddPX4EweR/MZrwL8NC40SW8otcHnrzX1StLmkpI6HZkyIBNRS0VSTg+IYm1yQxhW46tomeh6cDw!AU3GARXVUufheDkg0bO2yrzgy0rsRAMo1OQBir4K0svzCn0lbm7mtdFD+3/EvvjWF5uhL5JVQX5k
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: 10331
 by: olcott - Thu, 27 Jan 2022 04:37 UTC

On 1/26/2022 10:07 PM, Richard Damon wrote:
> On 1/26/22 10:59 PM, olcott wrote:
>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>> On 1/26/22 9:42 PM, olcott wrote:
>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>>>>> time due to patterns.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>>>>> some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>
>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>> actual execution path of the H that part of H^, not switch
>>>>>>>>>>>>> to tracing what it was tracing.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the
>>>>>>>>>>>> pattern:
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>>>>> can't give an answer.
>>>>>>>>>>>
>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the above
>>>>>>>>>>> is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>
>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>
>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>>>> accurate simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>>>>> then it needs to take into account that the machine it is
>>>>>>>>> simulating will do so too.
>>>>>>>>>
>>>>>>>>
>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>> according to the Linz definition:
>>>>>>>
>>>>>>>
>>>>>>> But it needs to prove that the UTM of its input never halts, and
>>>>>>> for H^, that means even if the H insisde H^ goes to H.Qn which
>>>>>>> means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>
>>>>>>
>>>>>> As soon as embedded_H (not H) determines that its simulated input
>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state in any
>>>>>> finite number of steps it terminates this simulation immediately
>>>>>> stopping every element of the entire chain of nested simulations.
>>>>>>
>>>>>
>>>>> If you are claiming that embedded_H and H behave differently then
>>>>> you have been lying that you built H^ by the instruction of Linz,
>>>>> as the copy of H inside H^ is IDENTICAL (except what happens AFTER
>>>>> getting to H.Qy)
>>>>>
>>>>> Now, IF H could make that proof, then it would be correct to go to
>>>>> H.Qn, but it would need to take into account that H^ halts if its
>>>>> copy of H goes to H.Qn, so this is NEVER possible.
>>>>>
>>>>> FAIL
>>>>>
>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>>>>> embedded_H and a decider is only accountable for computing the
>>>>>> mapping from its actual inputs to an accept or reject state it
>>>>>> makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>
>>>>> Thus you have admitted to LYING about working on the Halting
>>>>> problem as if you were the embedded_H would be the same algorithm
>>>>> as H, and the requirement on H was that is IS accoutable for the
>>>>> machine its input represents,
>>>>
>>>> You are simply too freaking stupid to understand that deciders thus
>>>> halt deciders are only accountable for computing the mapping from
>>>> their actual inputs (nothing else in the whole freaking universe
>>>> besides their actual inputs) to an accept or reject state.
>>>>
>>>> An actual computer scientist would know this.
>>>>
>>>
>>> It seems you don't understand the difference between capabilities and
>>> requirements.
>>>
>>> H is only CAPABLE of deciding based on what it can do. It can only
>>> computate a mapping based on what it actually can do.
>>>
>>> It is REQUIRED to meet its requirements, which is to decide on the
>>> behavior of what its input would do if given to a UTM.
>>>
>>
>> embedded_H must only determine whether or not is simulated input can
>> ever reach its final state in any finite number of steps.
>>
>
> Again, you seem to be lying about working on the Halting Problem and
> Linz proof.
>
> If you were working on the Halting Problem and Linz proof then
> embedded_H would be identical to H, as required by Linz, and the correct
> answer for the 'behavior' of the input to embedded_H <H^> <H^> would be
> the behavior of UTM(<H^>,<H^>) which if embedded_H goes to H.Qn then we
> know that H^ will go to H^.Qn and Halt, and thus H/embedded_H going to
> H.Qn is incorrect.
>
> So, you are just admitting that you are lying or are too stupid to
> understan what you are talking about.
>
> Which is it?
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<sstadm$q3d$1@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: SteveMc1...@hotmail.com (Steve)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Date: Wed, 26 Jan 2022 21:26:12 -0800
Organization: Aioe.org NNTP Server
Message-ID: <sstadm$q3d$1@gioia.aioe.org>
References: <ssh8vu$4c0$1@dont-email.me> <Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
Reply-To: SteveMc1974@hotmail.com
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="26733"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Content-Language: en-US
X-Notice: Filtered by postfilter v. 0.9.2
 by: Steve - Thu, 27 Jan 2022 05:26 UTC

On 1/26/2022 8:37 PM, olcott wrote:
> nothing <

Shut up idiot.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<t8SdnbDUhMmrs2_8nZ2dnUU7-SWdnZ2d@giganews.com>

 copy mid

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

 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, 26 Jan 2022 23:31:34 -0600
Date: Wed, 26 Jan 2022 23:31:33 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com> <sstadm$q3d$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sstadm$q3d$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <t8SdnbDUhMmrs2_8nZ2dnUU7-SWdnZ2d@giganews.com>
Lines: 14
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SyEfP/vcy1vgH7x6ERKO7wG+frsrYN3hlNtBTA2y2T0WEUl+niXvltDpF/+NSaoxrbazT+/ymTYKwT9!NQKz6Ekpi5lakDtqjeC6E0wDvvHvc0N/mbN9y4Iu99dN5nmT9Uct45dJxkLot/dM5IbqavAquV+4
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: 2470
 by: olcott - Thu, 27 Jan 2022 05:31 UTC

On 1/26/2022 11:26 PM, Steve wrote:
> On 1/26/2022 8:37 PM, olcott wrote:
>> nothing <
>
> Shut up idiot.

Clearly you are the idiot.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<7MvIJ.16685$V31.12106@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer01.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.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 203
Message-ID: <7MvIJ.16685$V31.12106@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: Thu, 27 Jan 2022 06:56:51 -0500
X-Received-Bytes: 11002
X-Original-Bytes: 10868
 by: Richard Damon - Thu, 27 Jan 2022 11:56 UTC

On 1/26/22 11:37 PM, olcott wrote:
> On 1/26/2022 10:07 PM, Richard Damon wrote:
>> On 1/26/22 10:59 PM, olcott wrote:
>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>>>>>> time due to patterns.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>>>>>> some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>> only really infinite when you work them out to infinitity.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>>> actual execution path of the H that part of H^, not switch
>>>>>>>>>>>>>> to tracing what it was tracing.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is
>>>>>>>>>>>>> the pattern:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>>>>>> can't give an answer.
>>>>>>>>>>>>
>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the above
>>>>>>>>>>>> is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>
>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>
>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>
>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>>>>> accurate simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>>>>>> then it needs to take into account that the machine it is
>>>>>>>>>> simulating will do so too.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>>> according to the Linz definition:
>>>>>>>>
>>>>>>>>
>>>>>>>> But it needs to prove that the UTM of its input never halts, and
>>>>>>>> for H^, that means even if the H insisde H^ goes to H.Qn which
>>>>>>>> means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>
>>>>>>>
>>>>>>> As soon as embedded_H (not H) determines that its simulated input
>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state in any
>>>>>>> finite number of steps it terminates this simulation immediately
>>>>>>> stopping every element of the entire chain of nested simulations.
>>>>>>>
>>>>>>
>>>>>> If you are claiming that embedded_H and H behave differently then
>>>>>> you have been lying that you built H^ by the instruction of Linz,
>>>>>> as the copy of H inside H^ is IDENTICAL (except what happens AFTER
>>>>>> getting to H.Qy)
>>>>>>
>>>>>> Now, IF H could make that proof, then it would be correct to go to
>>>>>> H.Qn, but it would need to take into account that H^ halts if its
>>>>>> copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>
>>>>>> FAIL
>>>>>>
>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>>>>>> embedded_H and a decider is only accountable for computing the
>>>>>>> mapping from its actual inputs to an accept or reject state it
>>>>>>> makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>
>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>> problem as if you were the embedded_H would be the same algorithm
>>>>>> as H, and the requirement on H was that is IS accoutable for the
>>>>>> machine its input represents,
>>>>>
>>>>> You are simply too freaking stupid to understand that deciders thus
>>>>> halt deciders are only accountable for computing the mapping from
>>>>> their actual inputs (nothing else in the whole freaking universe
>>>>> besides their actual inputs) to an accept or reject state.
>>>>>
>>>>> An actual computer scientist would know this.
>>>>>
>>>>
>>>> It seems you don't understand the difference between capabilities
>>>> and requirements.
>>>>
>>>> H is only CAPABLE of deciding based on what it can do. It can only
>>>> computate a mapping based on what it actually can do.
>>>>
>>>> It is REQUIRED to meet its requirements, which is to decide on the
>>>> behavior of what its input would do if given to a UTM.
>>>>
>>>
>>> embedded_H must only determine whether or not is simulated input can
>>> ever reach its final state in any finite number of steps.
>>>
>>
>> Again, you seem to be lying about working on the Halting Problem and
>> Linz proof.
>>
>> If you were working on the Halting Problem and Linz proof then
>> embedded_H would be identical to H, as required by Linz, and the
>> correct answer for the 'behavior' of the input to embedded_H <H^> <H^>
>> would be the behavior of UTM(<H^>,<H^>) which if embedded_H goes to
>> H.Qn then we know that H^ will go to H^.Qn and Halt, and thus
>> H/embedded_H going to H.Qn is incorrect.
>>
>> So, you are just admitting that you are lying or are too stupid to
>> understan what you are talking about.
>>
>> Which is it?
>>
>
> I will not tolerate any digression from the point at hand until we have
> mutual agreement. This is verified as completely true entirely on the
> basis of the meaning of its words:
>
> embedded_H must only determine whether or not its simulated input can
> ever reach its final state in any finite number of steps.
>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<ssudgi$3gj$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Followup-To: comp.theory
Date: Thu, 27 Jan 2022 09:25:04 -0600
Organization: A noiseless patient Spider
Lines: 202
Message-ID: <ssudgi$3gj$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
<7MvIJ.16685$V31.12106@fx47.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 27 Jan 2022 15:25:06 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="373489d2d6a220e692ee02a77dd0e5a7";
logging-data="3603"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19qnI25Q8zptSPSDSe9+bxi"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:FaFkobH0USt9ezfnALXSoVuj/oA=
In-Reply-To: <7MvIJ.16685$V31.12106@fx47.iad>
Content-Language: en-US
 by: olcott - Thu, 27 Jan 2022 15:25 UTC

On 1/27/2022 5:56 AM, Richard Damon wrote:
> On 1/26/22 11:37 PM, olcott wrote:
>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>> On 1/26/22 10:59 PM, olcott wrote:
>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that
>>>>>>>>>>>>>>> at some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>>> only really infinite when you work them out to infinitity.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>>>> actual execution path of the H that part of H^, not
>>>>>>>>>>>>>>> switch to tracing what it was tracing.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is
>>>>>>>>>>>>>> the pattern:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the above
>>>>>>>>>>>>> is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>
>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>
>>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>>
>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>>>>>> accurate simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>>>> according to the Linz definition:
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But it needs to prove that the UTM of its input never halts,
>>>>>>>>> and for H^, that means even if the H insisde H^ goes to H.Qn
>>>>>>>>> which means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state
>>>>>>>> in any finite number of steps it terminates this simulation
>>>>>>>> immediately stopping every element of the entire chain of nested
>>>>>>>> simulations.
>>>>>>>>
>>>>>>>
>>>>>>> If you are claiming that embedded_H and H behave differently then
>>>>>>> you have been lying that you built H^ by the instruction of Linz,
>>>>>>> as the copy of H inside H^ is IDENTICAL (except what happens
>>>>>>> AFTER getting to H.Qy)
>>>>>>>
>>>>>>> Now, IF H could make that proof, then it would be correct to go
>>>>>>> to H.Qn, but it would need to take into account that H^ halts if
>>>>>>> its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>
>>>>>>> FAIL
>>>>>>>
>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input
>>>>>>>> to embedded_H and a decider is only accountable for computing
>>>>>>>> the mapping from its actual inputs to an accept or reject state
>>>>>>>> it makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>
>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>> problem as if you were the embedded_H would be the same algorithm
>>>>>>> as H, and the requirement on H was that is IS accoutable for the
>>>>>>> machine its input represents,
>>>>>>
>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>> thus halt deciders are only accountable for computing the mapping
>>>>>> from their actual inputs (nothing else in the whole freaking
>>>>>> universe besides their actual inputs) to an accept or reject state.
>>>>>>
>>>>>> An actual computer scientist would know this.
>>>>>>
>>>>>
>>>>> It seems you don't understand the difference between capabilities
>>>>> and requirements.
>>>>>
>>>>> H is only CAPABLE of deciding based on what it can do. It can only
>>>>> computate a mapping based on what it actually can do.
>>>>>
>>>>> It is REQUIRED to meet its requirements, which is to decide on the
>>>>> behavior of what its input would do if given to a UTM.
>>>>>
>>>>
>>>> embedded_H must only determine whether or not is simulated input can
>>>> ever reach its final state in any finite number of steps.
>>>>
>>>
>>> Again, you seem to be lying about working on the Halting Problem and
>>> Linz proof.
>>>
>>> If you were working on the Halting Problem and Linz proof then
>>> embedded_H would be identical to H, as required by Linz, and the
>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H goes
>>> to H.Qn then we know that H^ will go to H^.Qn and Halt, and thus
>>> H/embedded_H going to H.Qn is incorrect.
>>>
>>> So, you are just admitting that you are lying or are too stupid to
>>> understan what you are talking about.
>>>
>>> Which is it?
>>>
>>
>> I will not tolerate any digression from the point at hand until we
>> have mutual agreement. This is verified as completely true entirely on
>> the basis of the meaning of its words:
>>
>> embedded_H must only determine whether or not its simulated input can
>> ever reach its final state in any finite number of steps.
>>
>>
>
> Translation: You will ignroe any disagreement with your incorrect
> statement because you need to get people to accept your falso premise
> for your unsound argument to work.
>
> The problem with your statement is that you are showing that you atually
> mean something different than the true meaning of the words.
>
> H (and thus embedded_H) need to determine whether or not its simuleted
> input will ever reach its final state for EVERY POSSIBLE finite number
> of steps, i.e. as determine by a UTM.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<ssue1i$81l$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.math sci.logic
Followup: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.math,sci.logic
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Followup-To: comp.theory
Date: Thu, 27 Jan 2022 09:34:08 -0600
Organization: A noiseless patient Spider
Lines: 209
Message-ID: <ssue1i$81l$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me> <UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
<7MvIJ.16685$V31.12106@fx47.iad> <ssudgi$3gj$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 27 Jan 2022 15:34:10 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="373489d2d6a220e692ee02a77dd0e5a7";
logging-data="8245"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19Hqmm9SrVqoT/M5S0svHhn"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:LJcEDFkBuF4/v6kIVzJFXZ7frdo=
In-Reply-To: <ssudgi$3gj$1@dont-email.me>
Content-Language: en-US
 by: olcott - Thu, 27 Jan 2022 15:34 UTC

On 1/27/2022 9:25 AM, olcott wrote:
> On 1/27/2022 5:56 AM, Richard Damon wrote:
>> On 1/26/22 11:37 PM, olcott wrote:
>>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>>> On 1/26/22 10:59 PM, olcott wrote:
>>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>>>>> simulation of an infinite sequence of configurations
>>>>>>>>>>>>>>>>> can recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that
>>>>>>>>>>>>>>>> at some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>>>> only really infinite when you work them out to infinitity.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>>>>> actual execution path of the H that part of H^, not
>>>>>>>>>>>>>>>> switch to tracing what it was tracing.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>> the pattern:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the
>>>>>>>>>>>>>> above is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>>
>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>
>>>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not
>>>>>>>>>>>>> an accurate simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>>>>> according to the Linz definition:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But it needs to prove that the UTM of its input never halts,
>>>>>>>>>> and for H^, that means even if the H insisde H^ goes to H.Qn
>>>>>>>>>> which means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state
>>>>>>>>> in any finite number of steps it terminates this simulation
>>>>>>>>> immediately stopping every element of the entire chain of
>>>>>>>>> nested simulations.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you are claiming that embedded_H and H behave differently
>>>>>>>> then you have been lying that you built H^ by the instruction of
>>>>>>>> Linz, as the copy of H inside H^ is IDENTICAL (except what
>>>>>>>> happens AFTER getting to H.Qy)
>>>>>>>>
>>>>>>>> Now, IF H could make that proof, then it would be correct to go
>>>>>>>> to H.Qn, but it would need to take into account that H^ halts if
>>>>>>>> its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>>
>>>>>>>> FAIL
>>>>>>>>
>>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input
>>>>>>>>> to embedded_H and a decider is only accountable for computing
>>>>>>>>> the mapping from its actual inputs to an accept or reject state
>>>>>>>>> it makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>>
>>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>>> problem as if you were the embedded_H would be the same
>>>>>>>> algorithm as H, and the requirement on H was that is IS
>>>>>>>> accoutable for the machine its input represents,
>>>>>>>
>>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>>> thus halt deciders are only accountable for computing the mapping
>>>>>>> from their actual inputs (nothing else in the whole freaking
>>>>>>> universe besides their actual inputs) to an accept or reject state.
>>>>>>>
>>>>>>> An actual computer scientist would know this.
>>>>>>>
>>>>>>
>>>>>> It seems you don't understand the difference between capabilities
>>>>>> and requirements.
>>>>>>
>>>>>> H is only CAPABLE of deciding based on what it can do. It can only
>>>>>> computate a mapping based on what it actually can do.
>>>>>>
>>>>>> It is REQUIRED to meet its requirements, which is to decide on the
>>>>>> behavior of what its input would do if given to a UTM.
>>>>>>
>>>>>
>>>>> embedded_H must only determine whether or not is simulated input
>>>>> can ever reach its final state in any finite number of steps.
>>>>>
>>>>
>>>> Again, you seem to be lying about working on the Halting Problem and
>>>> Linz proof.
>>>>
>>>> If you were working on the Halting Problem and Linz proof then
>>>> embedded_H would be identical to H, as required by Linz, and the
>>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H
>>>> goes to H.Qn then we know that H^ will go to H^.Qn and Halt, and
>>>> thus H/embedded_H going to H.Qn is incorrect.
>>>>
>>>> So, you are just admitting that you are lying or are too stupid to
>>>> understan what you are talking about.
>>>>
>>>> Which is it?
>>>>
>>>
>>> I will not tolerate any digression from the point at hand until we
>>> have mutual agreement. This is verified as completely true entirely
>>> on the basis of the meaning of its words:
>>>
>>> embedded_H must only determine whether or not its simulated input can
>>> ever reach its final state in any finite number of steps.
>>>
>>>
>>
>> Translation: You will ignroe any disagreement with your incorrect
>> statement because you need to get people to accept your falso premise
>> for your unsound argument to work.
>>
>> The problem with your statement is that you are showing that you
>> atually mean something different than the true meaning of the words.
>>
>> H (and thus embedded_H) need to determine whether or not its simuleted
>> input will ever reach its final state for EVERY POSSIBLE finite number
>> of steps, i.e. as determine by a UTM.
>>
>
> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<AfGIJ.3844$dV.1984@fx44.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.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!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
<7MvIJ.16685$V31.12106@fx47.iad> <ssudgi$3gj$1@dont-email.me>
<ssue1i$81l$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ssue1i$81l$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 238
Message-ID: <AfGIJ.3844$dV.1984@fx44.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 27 Jan 2022 18:53:04 -0500
X-Received-Bytes: 12956
 by: Richard Damon - Thu, 27 Jan 2022 23:53 UTC

On 1/27/22 10:34 AM, olcott wrote:
> On 1/27/2022 9:25 AM, olcott wrote:
>> On 1/27/2022 5:56 AM, Richard Damon wrote:
>>> On 1/26/22 11:37 PM, olcott wrote:
>>>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>>>> On 1/26/22 10:59 PM, olcott wrote:
>>>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>>>>>> simulation of an infinite sequence of configurations
>>>>>>>>>>>>>>>>>> can recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that
>>>>>>>>>>>>>>>>> at some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>>>>> only really infinite when you work them out to infinitity.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>>>>>> actual execution path of the H that part of H^, not
>>>>>>>>>>>>>>>>> switch to tracing what it was tracing.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this
>>>>>>>>>>>>>>>> is the pattern:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the
>>>>>>>>>>>>>>> above is NOT the accurate trace of the behavior of the
>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not
>>>>>>>>>>>>>> an accurate simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>>>> cannot possibly reach its final state in any finite number
>>>>>>>>>>>> of steps it has conclusively proved that this input never
>>>>>>>>>>>> halts according to the Linz definition:
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But it needs to prove that the UTM of its input never halts,
>>>>>>>>>>> and for H^, that means even if the H insisde H^ goes to H.Qn
>>>>>>>>>>> which means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state
>>>>>>>>>> in any finite number of steps it terminates this simulation
>>>>>>>>>> immediately stopping every element of the entire chain of
>>>>>>>>>> nested simulations.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you are claiming that embedded_H and H behave differently
>>>>>>>>> then you have been lying that you built H^ by the instruction
>>>>>>>>> of Linz, as the copy of H inside H^ is IDENTICAL (except what
>>>>>>>>> happens AFTER getting to H.Qy)
>>>>>>>>>
>>>>>>>>> Now, IF H could make that proof, then it would be correct to go
>>>>>>>>> to H.Qn, but it would need to take into account that H^ halts
>>>>>>>>> if its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>>>
>>>>>>>>> FAIL
>>>>>>>>>
>>>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an
>>>>>>>>>> input to embedded_H and a decider is only accountable for
>>>>>>>>>> computing the mapping from its actual inputs to an accept or
>>>>>>>>>> reject state it makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>>>
>>>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>>>> problem as if you were the embedded_H would be the same
>>>>>>>>> algorithm as H, and the requirement on H was that is IS
>>>>>>>>> accoutable for the machine its input represents,
>>>>>>>>
>>>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>>>> thus halt deciders are only accountable for computing the
>>>>>>>> mapping from their actual inputs (nothing else in the whole
>>>>>>>> freaking universe besides their actual inputs) to an accept or
>>>>>>>> reject state.
>>>>>>>>
>>>>>>>> An actual computer scientist would know this.
>>>>>>>>
>>>>>>>
>>>>>>> It seems you don't understand the difference between capabilities
>>>>>>> and requirements.
>>>>>>>
>>>>>>> H is only CAPABLE of deciding based on what it can do. It can
>>>>>>> only computate a mapping based on what it actually can do.
>>>>>>>
>>>>>>> It is REQUIRED to meet its requirements, which is to decide on
>>>>>>> the behavior of what its input would do if given to a UTM.
>>>>>>>
>>>>>>
>>>>>> embedded_H must only determine whether or not is simulated input
>>>>>> can ever reach its final state in any finite number of steps.
>>>>>>
>>>>>
>>>>> Again, you seem to be lying about working on the Halting Problem
>>>>> and Linz proof.
>>>>>
>>>>> If you were working on the Halting Problem and Linz proof then
>>>>> embedded_H would be identical to H, as required by Linz, and the
>>>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H
>>>>> goes to H.Qn then we know that H^ will go to H^.Qn and Halt, and
>>>>> thus H/embedded_H going to H.Qn is incorrect.
>>>>>
>>>>> So, you are just admitting that you are lying or are too stupid to
>>>>> understan what you are talking about.
>>>>>
>>>>> Which is it?
>>>>>
>>>>
>>>> I will not tolerate any digression from the point at hand until we
>>>> have mutual agreement. This is verified as completely true entirely
>>>> on the basis of the meaning of its words:
>>>>
>>>> embedded_H must only determine whether or not its simulated input can
>>>> ever reach its final state in any finite number of steps.
>>>>
>>>>
>>>
>>> Translation: You will ignroe any disagreement with your incorrect
>>> statement because you need to get people to accept your falso premise
>>> for your unsound argument to work.
>>>
>>> The problem with your statement is that you are showing that you
>>> atually mean something different than the true meaning of the words.
>>>
>>> H (and thus embedded_H) need to determine whether or not its
>>> simuleted input will ever reach its final state for EVERY POSSIBLE
>>> finite number of steps, i.e. as determine by a UTM.
>>>
>>
>> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps.
>
> Halts(⟨Ĥ⟩, ⟨Ĥ⟩) ≡
> (∃N such that the pure simulation of the input
> to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps)
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>

 copy mid

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

 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: Thu, 27 Jan 2022 18:14:32 -0600
Date: Thu, 27 Jan 2022 18:14:31 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
<7MvIJ.16685$V31.12106@fx47.iad> <ssudgi$3gj$1@dont-email.me>
<ssue1i$81l$1@dont-email.me> <AfGIJ.3844$dV.1984@fx44.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <AfGIJ.3844$dV.1984@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
Lines: 228
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SUNah8RqL8paqAtRDoJWwv4KcVWtg7AkRKQSUSCg6n9Pb9IMPaDmWzgmDF3csrTQysQnXpHOh/kRiBG!d3Q7d4v3XUY4Dt2AKxq8zsCmmu2LqNWUTR1VJcRZfRZZZOTKlyJw1zsV9ZhM6S6ZBjABeQ7m6CyF
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: 12772
 by: olcott - Fri, 28 Jan 2022 00:14 UTC

On 1/27/2022 5:53 PM, Richard Damon wrote:
> On 1/27/22 10:34 AM, olcott wrote:
>> On 1/27/2022 9:25 AM, olcott wrote:
>>> On 1/27/2022 5:56 AM, Richard Damon wrote:
>>>> On 1/26/22 11:37 PM, olcott wrote:
>>>>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>>>>> On 1/26/22 10:59 PM, olcott wrote:
>>>>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You keep coming back to the idea that only an
>>>>>>>>>>>>>>>>>>> infinite simulation of an infinite sequence of
>>>>>>>>>>>>>>>>>>> configurations can recognize an infinite sequence of
>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H
>>>>>>>>>>>>>>>>>> that at some point goest to H.Qn that correctly
>>>>>>>>>>>>>>>>>> detects the infinite behavior.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>>>>>> only really infinite when you work them out to
>>>>>>>>>>>>>>>>>> infinitity.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Part of your problem is that the traces you look at
>>>>>>>>>>>>>>>>>> are wrong. When H simulates H^, it needs to trace out
>>>>>>>>>>>>>>>>>> the actual execution path of the H that part of H^,
>>>>>>>>>>>>>>>>>> not switch to tracing what it was tracing.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this
>>>>>>>>>>>>>>>>> is the pattern:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the
>>>>>>>>>>>>>>>> above is NOT the accurate trace of the behavior of the
>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not
>>>>>>>>>>>>>>> an accurate simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>>>>> cannot possibly reach its final state in any finite number
>>>>>>>>>>>>> of steps it has conclusively proved that this input never
>>>>>>>>>>>>> halts according to the Linz definition:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But it needs to prove that the UTM of its input never halts,
>>>>>>>>>>>> and for H^, that means even if the H insisde H^ goes to H.Qn
>>>>>>>>>>>> which means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final
>>>>>>>>>>> state in any finite number of steps it terminates this
>>>>>>>>>>> simulation immediately stopping every element of the entire
>>>>>>>>>>> chain of nested simulations.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If you are claiming that embedded_H and H behave differently
>>>>>>>>>> then you have been lying that you built H^ by the instruction
>>>>>>>>>> of Linz, as the copy of H inside H^ is IDENTICAL (except what
>>>>>>>>>> happens AFTER getting to H.Qy)
>>>>>>>>>>
>>>>>>>>>> Now, IF H could make that proof, then it would be correct to
>>>>>>>>>> go to H.Qn, but it would need to take into account that H^
>>>>>>>>>> halts if its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>>>>
>>>>>>>>>> FAIL
>>>>>>>>>>
>>>>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original
>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an
>>>>>>>>>>> input to embedded_H and a decider is only accountable for
>>>>>>>>>>> computing the mapping from its actual inputs to an accept or
>>>>>>>>>>> reject state it makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>>>>
>>>>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>>>>> problem as if you were the embedded_H would be the same
>>>>>>>>>> algorithm as H, and the requirement on H was that is IS
>>>>>>>>>> accoutable for the machine its input represents,
>>>>>>>>>
>>>>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>>>>> thus halt deciders are only accountable for computing the
>>>>>>>>> mapping from their actual inputs (nothing else in the whole
>>>>>>>>> freaking universe besides their actual inputs) to an accept or
>>>>>>>>> reject state.
>>>>>>>>>
>>>>>>>>> An actual computer scientist would know this.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It seems you don't understand the difference between
>>>>>>>> capabilities and requirements.
>>>>>>>>
>>>>>>>> H is only CAPABLE of deciding based on what it can do. It can
>>>>>>>> only computate a mapping based on what it actually can do.
>>>>>>>>
>>>>>>>> It is REQUIRED to meet its requirements, which is to decide on
>>>>>>>> the behavior of what its input would do if given to a UTM.
>>>>>>>>
>>>>>>>
>>>>>>> embedded_H must only determine whether or not is simulated input
>>>>>>> can ever reach its final state in any finite number of steps.
>>>>>>>
>>>>>>
>>>>>> Again, you seem to be lying about working on the Halting Problem
>>>>>> and Linz proof.
>>>>>>
>>>>>> If you were working on the Halting Problem and Linz proof then
>>>>>> embedded_H would be identical to H, as required by Linz, and the
>>>>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>>>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H
>>>>>> goes to H.Qn then we know that H^ will go to H^.Qn and Halt, and
>>>>>> thus H/embedded_H going to H.Qn is incorrect.
>>>>>>
>>>>>> So, you are just admitting that you are lying or are too stupid to
>>>>>> understan what you are talking about.
>>>>>>
>>>>>> Which is it?
>>>>>>
>>>>>
>>>>> I will not tolerate any digression from the point at hand until we
>>>>> have mutual agreement. This is verified as completely true entirely
>>>>> on the basis of the meaning of its words:
>>>>>
>>>>> embedded_H must only determine whether or not its simulated input can
>>>>> ever reach its final state in any finite number of steps.
>>>>>
>>>>>
>>>>
>>>> Translation: You will ignroe any disagreement with your incorrect
>>>> statement because you need to get people to accept your falso
>>>> premise for your unsound argument to work.
>>>>
>>>> The problem with your statement is that you are showing that you
>>>> atually mean something different than the true meaning of the words.
>>>>
>>>> H (and thus embedded_H) need to determine whether or not its
>>>> simuleted input will ever reach its final state for EVERY POSSIBLE
>>>> finite number of steps, i.e. as determine by a UTM.
>>>>
>>>
>>> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps.
>>
>
> Except that it does unless you are lying about H^ being built right, at
> least if H(<H^>,<H^>) -> H.Qn, and it doesn't matter what H^ does if H
> doesn't go to H.Qn, as H is then wrong because it didn't answer.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<UHGIJ.15876$mS1.15729@fx10.iad>

 copy mid

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

 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!fx10.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
<7MvIJ.16685$V31.12106@fx47.iad> <ssudgi$3gj$1@dont-email.me>
<ssue1i$81l$1@dont-email.me> <AfGIJ.3844$dV.1984@fx44.iad>
<sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 234
Message-ID: <UHGIJ.15876$mS1.15729@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 27 Jan 2022 19:23:16 -0500
X-Received-Bytes: 13045
X-Original-Bytes: 12911
 by: Richard Damon - Fri, 28 Jan 2022 00:23 UTC

On 1/27/22 7:14 PM, olcott wrote:
> On 1/27/2022 5:53 PM, Richard Damon wrote:
>> On 1/27/22 10:34 AM, olcott wrote:
>>> On 1/27/2022 9:25 AM, olcott wrote:
>>>> On 1/27/2022 5:56 AM, Richard Damon wrote:
>>>>> On 1/26/22 11:37 PM, olcott wrote:
>>>>>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 10:59 PM, olcott wrote:
>>>>>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You keep coming back to the idea that only an
>>>>>>>>>>>>>>>>>>>> infinite simulation of an infinite sequence of
>>>>>>>>>>>>>>>>>>>> configurations can recognize an infinite sequence of
>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H
>>>>>>>>>>>>>>>>>>> that at some point goest to H.Qn that correctly
>>>>>>>>>>>>>>>>>>> detects the infinite behavior.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns
>>>>>>>>>>>>>>>>>>> are only really infinite when you work them out to
>>>>>>>>>>>>>>>>>>> infinitity.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Part of your problem is that the traces you look at
>>>>>>>>>>>>>>>>>>> are wrong. When H simulates H^, it needs to trace out
>>>>>>>>>>>>>>>>>>> the actual execution path of the H that part of H^,
>>>>>>>>>>>>>>>>>>> not switch to tracing what it was tracing.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You simply lack the intellectual capacity to
>>>>>>>>>>>>>>>>>> understand that when embedded_H simulates ⟨Ĥ⟩ applied
>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ this is the pattern:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the
>>>>>>>>>>>>>>>>> above is NOT the accurate trace of the behavior of the
>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You exactly same jackass point equally applies to this
>>>>>>>>>>>>>>>> case:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is
>>>>>>>>>>>>>>>> not an accurate simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>>>>>> cannot possibly reach its final state in any finite number
>>>>>>>>>>>>>> of steps it has conclusively proved that this input never
>>>>>>>>>>>>>> halts according to the Linz definition:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it needs to prove that the UTM of its input never
>>>>>>>>>>>>> halts, and for H^, that means even if the H insisde H^ goes
>>>>>>>>>>>>> to H.Qn which means that H^ goes to H^.Qn, which of course
>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final
>>>>>>>>>>>> state in any finite number of steps it terminates this
>>>>>>>>>>>> simulation immediately stopping every element of the entire
>>>>>>>>>>>> chain of nested simulations.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If you are claiming that embedded_H and H behave differently
>>>>>>>>>>> then you have been lying that you built H^ by the instruction
>>>>>>>>>>> of Linz, as the copy of H inside H^ is IDENTICAL (except what
>>>>>>>>>>> happens AFTER getting to H.Qy)
>>>>>>>>>>>
>>>>>>>>>>> Now, IF H could make that proof, then it would be correct to
>>>>>>>>>>> go to H.Qn, but it would need to take into account that H^
>>>>>>>>>>> halts if its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>>>>>
>>>>>>>>>>> FAIL
>>>>>>>>>>>
>>>>>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the
>>>>>>>>>>>> original Ĥ applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is
>>>>>>>>>>>> not an input to embedded_H and a decider is only accountable
>>>>>>>>>>>> for computing the mapping from its actual inputs to an
>>>>>>>>>>>> accept or reject state it makes no difference that Ĥ applied
>>>>>>>>>>>> to ⟨Ĥ⟩ halts.
>>>>>>>>>>>
>>>>>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>>>>>> problem as if you were the embedded_H would be the same
>>>>>>>>>>> algorithm as H, and the requirement on H was that is IS
>>>>>>>>>>> accoutable for the machine its input represents,
>>>>>>>>>>
>>>>>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>>>>>> thus halt deciders are only accountable for computing the
>>>>>>>>>> mapping from their actual inputs (nothing else in the whole
>>>>>>>>>> freaking universe besides their actual inputs) to an accept or
>>>>>>>>>> reject state.
>>>>>>>>>>
>>>>>>>>>> An actual computer scientist would know this.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It seems you don't understand the difference between
>>>>>>>>> capabilities and requirements.
>>>>>>>>>
>>>>>>>>> H is only CAPABLE of deciding based on what it can do. It can
>>>>>>>>> only computate a mapping based on what it actually can do.
>>>>>>>>>
>>>>>>>>> It is REQUIRED to meet its requirements, which is to decide on
>>>>>>>>> the behavior of what its input would do if given to a UTM.
>>>>>>>>>
>>>>>>>>
>>>>>>>> embedded_H must only determine whether or not is simulated input
>>>>>>>> can ever reach its final state in any finite number of steps.
>>>>>>>>
>>>>>>>
>>>>>>> Again, you seem to be lying about working on the Halting Problem
>>>>>>> and Linz proof.
>>>>>>>
>>>>>>> If you were working on the Halting Problem and Linz proof then
>>>>>>> embedded_H would be identical to H, as required by Linz, and the
>>>>>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>>>>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H
>>>>>>> goes to H.Qn then we know that H^ will go to H^.Qn and Halt, and
>>>>>>> thus H/embedded_H going to H.Qn is incorrect.
>>>>>>>
>>>>>>> So, you are just admitting that you are lying or are too stupid
>>>>>>> to understan what you are talking about.
>>>>>>>
>>>>>>> Which is it?
>>>>>>>
>>>>>>
>>>>>> I will not tolerate any digression from the point at hand until we
>>>>>> have mutual agreement. This is verified as completely true
>>>>>> entirely on the basis of the meaning of its words:
>>>>>>
>>>>>> embedded_H must only determine whether or not its simulated input can
>>>>>> ever reach its final state in any finite number of steps.
>>>>>>
>>>>>>
>>>>>
>>>>> Translation: You will ignroe any disagreement with your incorrect
>>>>> statement because you need to get people to accept your falso
>>>>> premise for your unsound argument to work.
>>>>>
>>>>> The problem with your statement is that you are showing that you
>>>>> atually mean something different than the true meaning of the words.
>>>>>
>>>>> H (and thus embedded_H) need to determine whether or not its
>>>>> simuleted input will ever reach its final state for EVERY POSSIBLE
>>>>> finite number of steps, i.e. as determine by a UTM.
>>>>>
>>>>
>>>> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps.
>>>
>>
>> Except that it does unless you are lying about H^ being built right,
>> at least if H(<H^>,<H^>) -> H.Qn, and it doesn't matter what H^ does
>> if H doesn't go to H.Qn, as H is then wrong because it didn't answer.
>>
>
> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps, otherwise ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> specifies a sequence of configurations that do not halt
>
> even if they stop running because the simulation has been aborted.
>
> I said that incorrectly only the above way of saying it is accurate, the
> second way of saying it can be misinterpreted.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 27 Jan 2022 18:47:50 -0600
Date: Thu, 27 Jan 2022 18:47:49 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <S64IJ.27704$7U.16191@fx42.iad>
<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
<9k4IJ.15452$jb4.2046@fx24.iad>
<SNudnYZfaZX6Tm38nZ2dnUU7-I3NnZ2d@giganews.com> <LMaIJ.8332$V31.330@fx47.iad>
<hsCdneOV_eybwGz8nZ2dnUU7-KPNnZ2d@giganews.com> <xalIJ.8632$rQ.8159@fx18.iad>
<r8OdnZwzO4tUf2z8nZ2dnUU7-SnNnZ2d@giganews.com> <eXlIJ.16438$2W.334@fx36.iad>
<zIKdnXB_n-rDbWz8nZ2dnUU7-enNnZ2d@giganews.com> <0wmIJ.176$XDR2.80@fx02.iad>
<37adnXNhdcJynW_8nZ2dnUU7-d3NnZ2d@giganews.com>
<csnIJ.19295$OU.5598@fx22.iad>
<vvWdnWkD_aAWm2_8nZ2dnUU7-UHNnZ2d@giganews.com> <N9oIJ.384$N31.159@fx45.iad>
<PaqdncLyCYZdhW_8nZ2dnUU7-evNnZ2d@giganews.com>
<JToIJ.296644$1d1.101887@fx99.iad>
<QZWdncKZjYg0vG_8nZ2dnUU7-SPNnZ2d@giganews.com>
<7MvIJ.16685$V31.12106@fx47.iad> <ssudgi$3gj$1@dont-email.me>
<ssue1i$81l$1@dont-email.me> <AfGIJ.3844$dV.1984@fx44.iad>
<sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <UHGIJ.15876$mS1.15729@fx10.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 258
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-x2ve4jttlc/HOr8C80JX+N8oPaobKZ2S4cZVdsICiG28Cq6hvyBAVHxdjZzyV3eqk/qStJpMLV45QpG!VbDvi911PC6Z1po/+pp7afeI2xyRzG0qEmoyDacbOLtK8jj6GH3z10Y7J/DVwpbA8gADC7llJf5D
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: 14356
 by: olcott - Fri, 28 Jan 2022 00:47 UTC

On 1/27/2022 6:23 PM, Richard Damon wrote:
> On 1/27/22 7:14 PM, olcott wrote:
>> On 1/27/2022 5:53 PM, Richard Damon wrote:
>>> On 1/27/22 10:34 AM, olcott wrote:
>>>> On 1/27/2022 9:25 AM, olcott wrote:
>>>>> On 1/27/2022 5:56 AM, Richard Damon wrote:
>>>>>> On 1/26/22 11:37 PM, olcott wrote:
>>>>>>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 10:59 PM, olcott wrote:
>>>>>>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>>>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You keep coming back to the idea that only an
>>>>>>>>>>>>>>>>>>>>> infinite simulation of an infinite sequence of
>>>>>>>>>>>>>>>>>>>>> configurations can recognize an infinite sequence
>>>>>>>>>>>>>>>>>>>>> of configurations.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H
>>>>>>>>>>>>>>>>>>>> that at some point goest to H.Qn that correctly
>>>>>>>>>>>>>>>>>>>> detects the infinite behavior.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns
>>>>>>>>>>>>>>>>>>>> are only really infinite when you work them out to
>>>>>>>>>>>>>>>>>>>> infinitity.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Part of your problem is that the traces you look at
>>>>>>>>>>>>>>>>>>>> are wrong. When H simulates H^, it needs to trace
>>>>>>>>>>>>>>>>>>>> out the actual execution path of the H that part of
>>>>>>>>>>>>>>>>>>>> H^, not switch to tracing what it was tracing.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You simply lack the intellectual capacity to
>>>>>>>>>>>>>>>>>>> understand that when embedded_H simulates ⟨Ĥ⟩ applied
>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ this is the pattern:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation
>>>>>>>>>>>>>>>>>> and thus can't give an answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the
>>>>>>>>>>>>>>>>>> above is NOT the accurate trace of the behavior of the
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You exactly same jackass point equally applies to this
>>>>>>>>>>>>>>>>> case:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is
>>>>>>>>>>>>>>>>> not an accurate simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As long as H correctly determines that its simulated
>>>>>>>>>>>>>>> input cannot possibly reach its final state in any finite
>>>>>>>>>>>>>>> number of steps it has conclusively proved that this
>>>>>>>>>>>>>>> input never halts according to the Linz definition:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But it needs to prove that the UTM of its input never
>>>>>>>>>>>>>> halts, and for H^, that means even if the H insisde H^
>>>>>>>>>>>>>> goes to H.Qn which means that H^ goes to H^.Qn, which of
>>>>>>>>>>>>>> course Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final
>>>>>>>>>>>>> state in any finite number of steps it terminates this
>>>>>>>>>>>>> simulation immediately stopping every element of the entire
>>>>>>>>>>>>> chain of nested simulations.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If you are claiming that embedded_H and H behave differently
>>>>>>>>>>>> then you have been lying that you built H^ by the
>>>>>>>>>>>> instruction of Linz, as the copy of H inside H^ is IDENTICAL
>>>>>>>>>>>> (except what happens AFTER getting to H.Qy)
>>>>>>>>>>>>
>>>>>>>>>>>> Now, IF H could make that proof, then it would be correct to
>>>>>>>>>>>> go to H.Qn, but it would need to take into account that H^
>>>>>>>>>>>> halts if its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL
>>>>>>>>>>>>
>>>>>>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the
>>>>>>>>>>>>> original Ĥ applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> is not an input to embedded_H and a decider is only
>>>>>>>>>>>>> accountable for computing the mapping from its actual
>>>>>>>>>>>>> inputs to an accept or reject state it makes no difference
>>>>>>>>>>>>> that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>>>>>>> problem as if you were the embedded_H would be the same
>>>>>>>>>>>> algorithm as H, and the requirement on H was that is IS
>>>>>>>>>>>> accoutable for the machine its input represents,
>>>>>>>>>>>
>>>>>>>>>>> You are simply too freaking stupid to understand that
>>>>>>>>>>> deciders thus halt deciders are only accountable for
>>>>>>>>>>> computing the mapping from their actual inputs (nothing else
>>>>>>>>>>> in the whole freaking universe besides their actual inputs)
>>>>>>>>>>> to an accept or reject state.
>>>>>>>>>>>
>>>>>>>>>>> An actual computer scientist would know this.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It seems you don't understand the difference between
>>>>>>>>>> capabilities and requirements.
>>>>>>>>>>
>>>>>>>>>> H is only CAPABLE of deciding based on what it can do. It can
>>>>>>>>>> only computate a mapping based on what it actually can do.
>>>>>>>>>>
>>>>>>>>>> It is REQUIRED to meet its requirements, which is to decide on
>>>>>>>>>> the behavior of what its input would do if given to a UTM.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> embedded_H must only determine whether or not is simulated
>>>>>>>>> input can ever reach its final state in any finite number of
>>>>>>>>> steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Again, you seem to be lying about working on the Halting Problem
>>>>>>>> and Linz proof.
>>>>>>>>
>>>>>>>> If you were working on the Halting Problem and Linz proof then
>>>>>>>> embedded_H would be identical to H, as required by Linz, and the
>>>>>>>> correct answer for the 'behavior' of the input to embedded_H
>>>>>>>> <H^> <H^> would be the behavior of UTM(<H^>,<H^>) which if
>>>>>>>> embedded_H goes to H.Qn then we know that H^ will go to H^.Qn
>>>>>>>> and Halt, and thus H/embedded_H going to H.Qn is incorrect.
>>>>>>>>
>>>>>>>> So, you are just admitting that you are lying or are too stupid
>>>>>>>> to understan what you are talking about.
>>>>>>>>
>>>>>>>> Which is it?
>>>>>>>>
>>>>>>>
>>>>>>> I will not tolerate any digression from the point at hand until
>>>>>>> we have mutual agreement. This is verified as completely true
>>>>>>> entirely on the basis of the meaning of its words:
>>>>>>>
>>>>>>> embedded_H must only determine whether or not its simulated input
>>>>>>> can
>>>>>>> ever reach its final state in any finite number of steps.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Translation: You will ignroe any disagreement with your incorrect
>>>>>> statement because you need to get people to accept your falso
>>>>>> premise for your unsound argument to work.
>>>>>>
>>>>>> The problem with your statement is that you are showing that you
>>>>>> atually mean something different than the true meaning of the words.
>>>>>>
>>>>>> H (and thus embedded_H) need to determine whether or not its
>>>>>> simuleted input will ever reach its final state for EVERY POSSIBLE
>>>>>> finite number of steps, i.e. as determine by a UTM.
>>>>>>
>>>>>
>>>>> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps.
>>>>
>>>
>>> Except that it does unless you are lying about H^ being built right,
>>> at least if H(<H^>,<H^>) -> H.Qn, and it doesn't matter what H^ does
>>> if H doesn't go to H.Qn, as H is then wrong because it didn't answer.
>>>
>>
>> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps, otherwise ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> specifies a sequence of configurations that do not halt
>>
>> even if they stop running because the simulation has been aborted.
>>
>> I said that incorrectly only the above way of saying it is accurate,
>> the second way of saying it can be misinterpreted.
>>
>
> Except the pure simulation of the inputs to H/embeddd_H don't stop when
> H/embedded_H abrot their simulation


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

rocksolid light 0.9.7
clearnet tor