Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Ahead warp factor 1" -- Captain Kirk

devel / comp.theory / Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

SubjectAuthor
* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
+* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
|`- Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
+* Hx(Px,Px)==0 is proven to be correct (refuting halting problemdklei...@gmail.com
|`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemPaul N
| |+- Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |   `- Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |     `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |      `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |       `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |        `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |         `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |          `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |           `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |            `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |             `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |              `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |               `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                 `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                     `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                      `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                       `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                        `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                         `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                          `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                           +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                           |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                           | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                           |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                           |   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                           |    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                           |     `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                           |      `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                           |       `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                           |        `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                           |         `- Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                           `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemPaul N
| |                            `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                             `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemPaul N
| |                              `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemMr Flibble
| |                               |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemMr Flibble
| |                               |  +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |  |`- Hx(Px,Px)==0 is proven to be correct (refuting halting problemMr Flibble
| |                               |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemPaul N
| |                               |   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |     `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |      `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |       `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |        +- Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |        `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |         `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |          `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |           `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |            `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |             `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |              `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |               `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                 `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                     `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |   `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |     `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |      `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |       `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |        `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |         `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |          `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |           +* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |           |`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |           | `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      |           |  `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
| |                               |    |                      |           `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    |                      `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemolcott
| |                               |    `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemPaul N
| |                               `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemPaul N
| `* Hx(Px,Px)==0 is proven to be correct (refuting halting problemdklei...@gmail.com
+* Hx(Px,Px)==0 is proven to be correct (refuting halting problemRichard Damon
`* Hx(Px,Px)==0 is proven to be correct (refuting halting problemMr Flibble

Pages:12345678
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg65qv$d3nv$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sat, 17 Sep 2022 23:12:14 -0500
Organization: A noiseless patient Spider
Lines: 1048
Message-ID: <tg65qv$d3nv$1@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <tg57nm$7qia$2@dont-email.me>
<20220917210210.000000a0@reddwarf.jmc.corp> <tg59n6$7qia$4@dont-email.me>
<f969ee83-2fbc-4873-a8f9-420e5a802773n@googlegroups.com>
<tg5ah7$7qia$5@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 04:12:15 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="429823"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19e7FeY8JBuI2SH3ef7FvGR"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:wcYCD2gahKdW24HjNSCadvMdazE=
In-Reply-To: <l7wVK.206653$PRW4.115367@fx11.iad>
Content-Language: en-US
 by: olcott - Sun, 18 Sep 2022 04:12 UTC

On 9/17/2022 10:19 PM, Richard Damon wrote:
> On 9/17/22 10:52 PM, olcott wrote:
>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>> On 9/17/22 9:38 PM, olcott wrote:
>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:31
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 4:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:42
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:18
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:08 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> September
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 16, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC-7,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of Hx Once again - what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> study every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that SOME
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on Hx's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not it must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create Px's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> valid then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it applies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wouldn't go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar when you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I SAY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input forever,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as H0,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct but the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutually exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your Simulationg
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Deciders ARENT'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but sets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is. Or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even what a computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which ONE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns 0 it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does this based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of every element of set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have TWO DIFFERENT H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just lying or proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something to be a decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly and completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given algorithm must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic representation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual operations that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of that class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Infinite_Loop never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is actually a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET OF DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we have deciders H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different computaiton
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and Infinite_loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system currently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic set you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it hasn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven by its complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition, but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOUR definition, as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that does the required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just as there NEVER is for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that give a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently fail
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to comprehend the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns that accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition doesn't allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defining that only the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to match in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HH(Px,Px) simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it understands that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it omits
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially" showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in thinking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation Execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion Detected
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion() is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine address
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it becomes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categorically exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough attention,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer > 5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P calls,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to get
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and instead
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me pointing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid mistakes"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a subset)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM THUS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone from,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s? That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves my
>>>>>>>>>>>>>>>>>>>>>>>>>> point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational code,
>>>>>>>>>>>>>>>>>>>>>>>>> it's a pretty safe bet that you will not
>>>>>>>>>>>>>>>>>>>>>>>>> actually run it and answer the following two
>>>>>>>>>>>>>>>>>>>>>>>>> questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>> contained in my project are named H/P and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>> is directly executed it directly executes Px(Px)
>>>>>>>>>>>>>>>>>>>>>>>> that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it doesn't
>>>>>>>>>>>>>>>>>>>>>>> matter that it makes a Px that is non-halting.
>>>>>>>>>>>>>>>>>>>>>>> That Hx FAILS just like you FAIL at being a
>>>>>>>>>>>>>>>>>>>>>>> correct decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0 does
>>>>>>>>>>>>>>>>>>>>>> this on the basis that it correctly matched a
>>>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern that correctly
>>>>>>>>>>>>>>>>>>>>>> proves that no Px element of the Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>> simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown to be
>>>>>>>>>>>>>>>>>>>>> incorrect, as the P(P) based on the H that uses it
>>>>>>>>>>>>>>>>>>>>> is Halting BECAUSE H matched its simulation to that
>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it proves
>>>>>>>>>>>>>>>>>>>> that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers the
>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they are
>>>>>>>>>>>>>>>>> answering the wrong question.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution of
>>>>>>>>>>>>>>>> Px(Px);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its direct
>>>>>>>>>>>>>>>> execution of its input, every Hx returning 0 does that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME the
>>>>>>>>>>>>>>> behavior of its direct execution of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>
>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for the Px
>>>>>>>>>>>>> built on it also creates a Px that when computing Px(Px)
>>>>>>>>>>>>> will halt in finite time since a simplified (but still
>>>>>>>>>>>>> correct) trace of Px(Px) would be:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px) will
>>>>>>>>>>>>> halt when computing Px(Px), that Hx is NOT correct to
>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A halt decider must predict what the behavior of its input
>>>>>>>>>>>>>> would be in the hypothetical case that it directly
>>>>>>>>>>>>>> executed its input. The means for it to do this are
>>>>>>>>>>>>>> unspecified, thus unconstrained:
>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but it needs to give an answer in finite time, and
>>>>>>>>>>>>> the RIGHT answer to be correct.
>>>>>>>>>>>>
>>>>>>>>>>>> This decider correctly determines that its direct execution
>>>>>>>>>>>> of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    return 0;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a LIE.
>>>>>>>>>>>
>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>> input would be (see above)
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>     return 0;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>
>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>
>>>>>>> So Px isn't calling it.
>>>>>>>
>>>>>>
>>>>>> A halt decider must always determine whether or not its direct
>>>>>> execution of its input would halt if it directly executed this
>>>>>> input and it must do this without actually directly executing it:
>>>>>> (a) Static analysis
>>>>>> (b) Partial simulation
>>>>>> (c) Wild guess
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>
>>>>> YOU FAIL.
>>>>>
>>>>> NO WHERE does the definition talk about deciding about *IT* doing a
>>>>> direct exectution.
>>>>>
>>>>
>>>> So you acknowledge that when Hx would directly execute its input
>>>> that this directly executed input would never halt?
>>>>
>>>>
>>>>
>>>
>>> If Hx DOES directly execute its input, then it will NEVER report
>>> non-halting, and yes, then the input Px built from THAT Hx will be
>>> non-halting.
>>>
>>
>> Then you also agree that another instance of Hx(Px,Px) that reports on
>> what the behavior of its direct execution of its input would be if it
>> did a direct execution of this input would be correct to return 0?
>>
>
> Another instance of that Hx CAN'T report that result, as it can only
> just execute its input, as that is what its algorithm says to do.


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg6c4p$di8k$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 00:59:51 -0500
Organization: A noiseless patient Spider
Lines: 1048
Message-ID: <tg6c4p$di8k$2@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <tg57nm$7qia$2@dont-email.me>
<20220917210210.000000a0@reddwarf.jmc.corp> <tg59n6$7qia$4@dont-email.me>
<f969ee83-2fbc-4873-a8f9-420e5a802773n@googlegroups.com>
<tg5ah7$7qia$5@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 05:59:54 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="444692"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19TNlPs0OdTe/8yGKOWRUj5"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:VXmCzrKPPuoO+LgMdAu+SgwypJs=
Content-Language: en-US
In-Reply-To: <l7wVK.206653$PRW4.115367@fx11.iad>
 by: olcott - Sun, 18 Sep 2022 05:59 UTC

On 9/17/2022 10:19 PM, Richard Damon wrote:
> On 9/17/22 10:52 PM, olcott wrote:
>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>> On 9/17/22 9:38 PM, olcott wrote:
>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:31
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 4:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:42
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:18
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:08 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> September
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 16, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC-7,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of Hx Once again - what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> study every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that SOME
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on Hx's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not it must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create Px's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> valid then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it applies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wouldn't go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar when you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I SAY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input forever,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as H0,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct but the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutually exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your Simulationg
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Deciders ARENT'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but sets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is. Or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even what a computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which ONE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns 0 it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does this based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of every element of set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have TWO DIFFERENT H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just lying or proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something to be a decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly and completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given algorithm must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic representation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual operations that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of that class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Infinite_Loop never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is actually a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET OF DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we have deciders H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different computaiton
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and Infinite_loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system currently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic set you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it hasn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven by its complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition, but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOUR definition, as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that does the required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just as there NEVER is for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that give a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently fail
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to comprehend the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns that accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition doesn't allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defining that only the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to match in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HH(Px,Px) simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it understands that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it omits
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially" showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in thinking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation Execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion Detected
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion() is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine address
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it becomes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categorically exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough attention,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer > 5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P calls,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to get
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and instead
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me pointing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid mistakes"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a subset)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM THUS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone from,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s? That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves my
>>>>>>>>>>>>>>>>>>>>>>>>>> point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational code,
>>>>>>>>>>>>>>>>>>>>>>>>> it's a pretty safe bet that you will not
>>>>>>>>>>>>>>>>>>>>>>>>> actually run it and answer the following two
>>>>>>>>>>>>>>>>>>>>>>>>> questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>> contained in my project are named H/P and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>> is directly executed it directly executes Px(Px)
>>>>>>>>>>>>>>>>>>>>>>>> that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it doesn't
>>>>>>>>>>>>>>>>>>>>>>> matter that it makes a Px that is non-halting.
>>>>>>>>>>>>>>>>>>>>>>> That Hx FAILS just like you FAIL at being a
>>>>>>>>>>>>>>>>>>>>>>> correct decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0 does
>>>>>>>>>>>>>>>>>>>>>> this on the basis that it correctly matched a
>>>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern that correctly
>>>>>>>>>>>>>>>>>>>>>> proves that no Px element of the Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>> simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown to be
>>>>>>>>>>>>>>>>>>>>> incorrect, as the P(P) based on the H that uses it
>>>>>>>>>>>>>>>>>>>>> is Halting BECAUSE H matched its simulation to that
>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it proves
>>>>>>>>>>>>>>>>>>>> that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers the
>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they are
>>>>>>>>>>>>>>>>> answering the wrong question.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution of
>>>>>>>>>>>>>>>> Px(Px);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its direct
>>>>>>>>>>>>>>>> execution of its input, every Hx returning 0 does that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME the
>>>>>>>>>>>>>>> behavior of its direct execution of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>
>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for the Px
>>>>>>>>>>>>> built on it also creates a Px that when computing Px(Px)
>>>>>>>>>>>>> will halt in finite time since a simplified (but still
>>>>>>>>>>>>> correct) trace of Px(Px) would be:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px) will
>>>>>>>>>>>>> halt when computing Px(Px), that Hx is NOT correct to
>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A halt decider must predict what the behavior of its input
>>>>>>>>>>>>>> would be in the hypothetical case that it directly
>>>>>>>>>>>>>> executed its input. The means for it to do this are
>>>>>>>>>>>>>> unspecified, thus unconstrained:
>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but it needs to give an answer in finite time, and
>>>>>>>>>>>>> the RIGHT answer to be correct.
>>>>>>>>>>>>
>>>>>>>>>>>> This decider correctly determines that its direct execution
>>>>>>>>>>>> of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    return 0;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a LIE.
>>>>>>>>>>>
>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>> input would be (see above)
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>     return 0;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>
>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>
>>>>>>> So Px isn't calling it.
>>>>>>>
>>>>>>
>>>>>> A halt decider must always determine whether or not its direct
>>>>>> execution of its input would halt if it directly executed this
>>>>>> input and it must do this without actually directly executing it:
>>>>>> (a) Static analysis
>>>>>> (b) Partial simulation
>>>>>> (c) Wild guess
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>
>>>>> YOU FAIL.
>>>>>
>>>>> NO WHERE does the definition talk about deciding about *IT* doing a
>>>>> direct exectution.
>>>>>
>>>>
>>>> So you acknowledge that when Hx would directly execute its input
>>>> that this directly executed input would never halt?
>>>>
>>>>
>>>>
>>>
>>> If Hx DOES directly execute its input, then it will NEVER report
>>> non-halting, and yes, then the input Px built from THAT Hx will be
>>> non-halting.
>>>
>>
>> Then you also agree that another instance of Hx(Px,Px) that reports on
>> what the behavior of its direct execution of its input would be if it
>> did a direct execution of this input would be correct to return 0?
>>
>
> Another instance of that Hx CAN'T report that result, as it can only
> just execute its input, as that is what its algorithm says to do.
>
This instance of Hx(Px,Px) correctly reports that its direct
execution of its input would never halt if it directly executed it:


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<ReDVK.206671$PRW4.150148@fx11.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me>
<20220917210210.000000a0@reddwarf.jmc.corp> <tg59n6$7qia$4@dont-email.me>
<f969ee83-2fbc-4873-a8f9-420e5a802773n@googlegroups.com>
<tg5ah7$7qia$5@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg6c4p$di8k$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg6c4p$di8k$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 1087
Message-ID: <ReDVK.206671$PRW4.150148@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 07:25:36 -0400
X-Received-Bytes: 68465
 by: Richard Damon - Sun, 18 Sep 2022 11:25 UTC

On 9/18/22 1:59 AM, olcott wrote:
> On 9/17/2022 10:19 PM, Richard Damon wrote:
>> On 9/17/22 10:52 PM, olcott wrote:
>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>> On 9/17/22 9:38 PM, olcott wrote:
>>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:31
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 4:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:42
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:08 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> September 16,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-7,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = Hx(x,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Once
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again -
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> study every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that SOME
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not it must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create Px's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> valid then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applies there.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wouldn't go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar when you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I SAY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input forever,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0, as implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct but the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutually exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your Simulationg
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARENT'T *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sets of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is. Or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even what a computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which ONE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does this based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of every element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have TWO DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just lying or proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something to be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly and completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given algorithm must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual operations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Infinite_Loop never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a SET OF DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we have deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different computaiton
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and Infinite_loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system currently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic set you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hasn't proven by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition, but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOUR definition, as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that does the required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just as there NEVER is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that give a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to comprehend the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns that accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition doesn't allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are defining that only the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in a finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider HH(Px,Px) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it understands that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it omits
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially" showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thinking that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation Execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5] 8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777] 50
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe] e8f4ffffff
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1] 8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777] 50
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe] e8f4ffffff
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion() is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine address
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes categorically exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough attention,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer >
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5 is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls, you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> get the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and instead
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointing out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid mistakes"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset) FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THUS KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from, a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s? That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves my
>>>>>>>>>>>>>>>>>>>>>>>>>>> point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational
>>>>>>>>>>>>>>>>>>>>>>>>>> code, it's a pretty safe bet that you will not
>>>>>>>>>>>>>>>>>>>>>>>>>> actually run it and answer the following two
>>>>>>>>>>>>>>>>>>>>>>>>>> questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>> contained in my project are named H/P and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>> is directly executed it directly executes
>>>>>>>>>>>>>>>>>>>>>>>>> Px(Px) that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it doesn't
>>>>>>>>>>>>>>>>>>>>>>>> matter that it makes a Px that is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>> That Hx FAILS just like you FAIL at being a
>>>>>>>>>>>>>>>>>>>>>>>> correct decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0 does
>>>>>>>>>>>>>>>>>>>>>>> this on the basis that it correctly matched a
>>>>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern that correctly
>>>>>>>>>>>>>>>>>>>>>>> proves that no Px element of the Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown to
>>>>>>>>>>>>>>>>>>>>>> be incorrect, as the P(P) based on the H that uses
>>>>>>>>>>>>>>>>>>>>>> it is Halting BECAUSE H matched its simulation to
>>>>>>>>>>>>>>>>>>>>>> that pattern.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it proves
>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers the
>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they are
>>>>>>>>>>>>>>>>>> answering the wrong question.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution of
>>>>>>>>>>>>>>>>> Px(Px);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its direct
>>>>>>>>>>>>>>>>> execution of its input, every Hx returning 0 does that.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME
>>>>>>>>>>>>>>>> the behavior of its direct execution of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for the
>>>>>>>>>>>>>> Px built on it also creates a Px that when computing
>>>>>>>>>>>>>> Px(Px) will halt in finite time since a simplified (but
>>>>>>>>>>>>>> still correct) trace of Px(Px) would be:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px)
>>>>>>>>>>>>>> will halt when computing Px(Px), that Hx is NOT correct to
>>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A halt decider must predict what the behavior of its
>>>>>>>>>>>>>>> input would be in the hypothetical case that it directly
>>>>>>>>>>>>>>> executed its input. The means for it to do this are
>>>>>>>>>>>>>>> unspecified, thus unconstrained:
>>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, but it needs to give an answer in finite time, and
>>>>>>>>>>>>>> the RIGHT answer to be correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This decider correctly determines that its direct execution
>>>>>>>>>>>>> of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>>
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a LIE.
>>>>>>>>>>>>
>>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>>> input would be (see above)
>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>     return 0;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>>
>>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>>
>>>>>>>> So Px isn't calling it.
>>>>>>>>
>>>>>>>
>>>>>>> A halt decider must always determine whether or not its direct
>>>>>>> execution of its input would halt if it directly executed this
>>>>>>> input and it must do this without actually directly executing it:
>>>>>>> (a) Static analysis
>>>>>>> (b) Partial simulation
>>>>>>> (c) Wild guess
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>>
>>>>>> YOU FAIL.
>>>>>>
>>>>>> NO WHERE does the definition talk about deciding about *IT* doing
>>>>>> a direct exectution.
>>>>>>
>>>>>
>>>>> So you acknowledge that when Hx would directly execute its input
>>>>> that this directly executed input would never halt?
>>>>>
>>>>>
>>>>>
>>>>
>>>> If Hx DOES directly execute its input, then it will NEVER report
>>>> non-halting, and yes, then the input Px built from THAT Hx will be
>>>> non-halting.
>>>>
>>>
>>> Then you also agree that another instance of Hx(Px,Px) that reports
>>> on what the behavior of its direct execution of its input would be if
>>> it did a direct execution of this input would be correct to return 0?
>>>
>>
>> Another instance of that Hx CAN'T report that result, as it can only
>> just execute its input, as that is what its algorithm says to do.
>>
> This instance of Hx(Px,Px) correctly reports that its direct
> execution of its input would never halt if it directly executed it:
>
> int Hx(ptr x, ptr y)
> {
>   return 0;
> }
>
>


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<fgDVK.206672$PRW4.133142@fx11.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me>
<20220917210210.000000a0@reddwarf.jmc.corp> <tg59n6$7qia$4@dont-email.me>
<f969ee83-2fbc-4873-a8f9-420e5a802773n@googlegroups.com>
<tg5ah7$7qia$5@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg65qv$d3nv$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 1092
Message-ID: <fgDVK.206672$PRW4.133142@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 07:27:07 -0400
X-Received-Bytes: 68555
 by: Richard Damon - Sun, 18 Sep 2022 11:27 UTC

On 9/18/22 12:12 AM, olcott wrote:
> On 9/17/2022 10:19 PM, Richard Damon wrote:
>> On 9/17/22 10:52 PM, olcott wrote:
>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>> On 9/17/22 9:38 PM, olcott wrote:
>>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:31
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 4:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:42
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:08 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> September 16,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-7,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = Hx(x,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Once
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again -
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> study every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that SOME
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not it must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create Px's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> valid then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applies there.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wouldn't go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar when you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I SAY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are the one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input forever,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0, as implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct but the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutually exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your Simulationg
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARENT'T *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sets of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is. Or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even what a computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which ONE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does this based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of every element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have TWO DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just lying or proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something to be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly and completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given algorithm must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual operations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Infinite_Loop never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a SET OF DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we have deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different computaiton
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and Infinite_loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system currently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic set you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hasn't proven by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition, but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOUR definition, as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that does the required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just as there NEVER is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that give a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to comprehend the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns that accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition doesn't allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are defining that only the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in a finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider HH(Px,Px) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it understands that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it omits
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially" showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thinking that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation Execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5] 8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777] 50
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe] e8f4ffffff
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1] 8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777] 50
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe] e8f4ffffff
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion() is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine address
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes categorically exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough attention,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer >
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5 is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls, you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> get the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and instead
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointing out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid mistakes"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset) FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THUS KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from, a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s? That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves my
>>>>>>>>>>>>>>>>>>>>>>>>>>> point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational
>>>>>>>>>>>>>>>>>>>>>>>>>> code, it's a pretty safe bet that you will not
>>>>>>>>>>>>>>>>>>>>>>>>>> actually run it and answer the following two
>>>>>>>>>>>>>>>>>>>>>>>>>> questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>> contained in my project are named H/P and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>> is directly executed it directly executes
>>>>>>>>>>>>>>>>>>>>>>>>> Px(Px) that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it doesn't
>>>>>>>>>>>>>>>>>>>>>>>> matter that it makes a Px that is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>> That Hx FAILS just like you FAIL at being a
>>>>>>>>>>>>>>>>>>>>>>>> correct decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0 does
>>>>>>>>>>>>>>>>>>>>>>> this on the basis that it correctly matched a
>>>>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern that correctly
>>>>>>>>>>>>>>>>>>>>>>> proves that no Px element of the Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown to
>>>>>>>>>>>>>>>>>>>>>> be incorrect, as the P(P) based on the H that uses
>>>>>>>>>>>>>>>>>>>>>> it is Halting BECAUSE H matched its simulation to
>>>>>>>>>>>>>>>>>>>>>> that pattern.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it proves
>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers the
>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they are
>>>>>>>>>>>>>>>>>> answering the wrong question.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution of
>>>>>>>>>>>>>>>>> Px(Px);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its direct
>>>>>>>>>>>>>>>>> execution of its input, every Hx returning 0 does that.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME
>>>>>>>>>>>>>>>> the behavior of its direct execution of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for the
>>>>>>>>>>>>>> Px built on it also creates a Px that when computing
>>>>>>>>>>>>>> Px(Px) will halt in finite time since a simplified (but
>>>>>>>>>>>>>> still correct) trace of Px(Px) would be:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px)
>>>>>>>>>>>>>> will halt when computing Px(Px), that Hx is NOT correct to
>>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A halt decider must predict what the behavior of its
>>>>>>>>>>>>>>> input would be in the hypothetical case that it directly
>>>>>>>>>>>>>>> executed its input. The means for it to do this are
>>>>>>>>>>>>>>> unspecified, thus unconstrained:
>>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, but it needs to give an answer in finite time, and
>>>>>>>>>>>>>> the RIGHT answer to be correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This decider correctly determines that its direct execution
>>>>>>>>>>>>> of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>>
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a LIE.
>>>>>>>>>>>>
>>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>>> input would be (see above)
>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>     return 0;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>>
>>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>>
>>>>>>>> So Px isn't calling it.
>>>>>>>>
>>>>>>>
>>>>>>> A halt decider must always determine whether or not its direct
>>>>>>> execution of its input would halt if it directly executed this
>>>>>>> input and it must do this without actually directly executing it:
>>>>>>> (a) Static analysis
>>>>>>> (b) Partial simulation
>>>>>>> (c) Wild guess
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>>
>>>>>> YOU FAIL.
>>>>>>
>>>>>> NO WHERE does the definition talk about deciding about *IT* doing
>>>>>> a direct exectution.
>>>>>>
>>>>>
>>>>> So you acknowledge that when Hx would directly execute its input
>>>>> that this directly executed input would never halt?
>>>>>
>>>>>
>>>>>
>>>>
>>>> If Hx DOES directly execute its input, then it will NEVER report
>>>> non-halting, and yes, then the input Px built from THAT Hx will be
>>>> non-halting.
>>>>
>>>
>>> Then you also agree that another instance of Hx(Px,Px) that reports
>>> on what the behavior of its direct execution of its input would be if
>>> it did a direct execution of this input would be correct to return 0?
>>>
>>
>> Another instance of that Hx CAN'T report that result, as it can only
>> just execute its input, as that is what its algorithm says to do.
>
>
> This instance of Hx(Px,Px) correctly reports its direct
> execution of its input never halts:
>
> int Hx(ptr x, ptr y)
> {
>   return 0;
> }
>


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<87o7vcloks.fsf@bsb.me.uk>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2
Date: Sun, 18 Sep 2022 15:55:15 +0100
Organization: A noiseless patient Spider
Lines: 11
Message-ID: <87o7vcloks.fsf@bsb.me.uk>
References: <tg27ie$3s073$1@dont-email.me> <tg5g4d$8g1j$3@dont-email.me>
<KHrVK.119006$479c.105120@fx48.iad> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg6c4p$di8k$2@dont-email.me>
<ReDVK.206671$PRW4.150148@fx11.iad>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="5ad823b9ed0f05b567ef739371d8f373";
logging-data="617473"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX197uiiCOjdNzmvab+5BkT6Bi5SviXlp7rQ="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:GPDMcroA0a2aPBu6LaH1NZo1Pb8=
sha1:cuax80gpIKz80CWZ/op8UDz6wJA=
X-BSB-Auth: 1.8d3710a35876d1d02e27.20220918155515BST.87o7vcloks.fsf@bsb.me.uk
 by: Ben Bacarisse - Sun, 18 Sep 2022 14:55 UTC

Richard Damon <Richard@Damon-Family.org> writes:
<massive quote>

> Except that ...

I admire your stamina, but were all 770+ lines of quoted material
(nested 66 levels deep!) really needed to give context for your 4-line
reply?

--
Ben.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7ct1$iutf$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 10:18:56 -0500
Organization: A noiseless patient Spider
Lines: 1104
Message-ID: <tg7ct1$iutf$1@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <tg59n6$7qia$4@dont-email.me>
<f969ee83-2fbc-4873-a8f9-420e5a802773n@googlegroups.com>
<tg5ah7$7qia$5@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 15:18:57 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="621487"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX196pbX8ItBkObqi//eqeVj8"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:EKZDShgjaA/9vgg9MV3sf15sums=
Content-Language: en-US
In-Reply-To: <fgDVK.206672$PRW4.133142@fx11.iad>
 by: olcott - Sun, 18 Sep 2022 15:18 UTC

On 9/18/2022 6:27 AM, Richard Damon wrote:
> On 9/18/22 12:12 AM, olcott wrote:
>> On 9/17/2022 10:19 PM, Richard Damon wrote:
>>> On 9/17/22 10:52 PM, olcott wrote:
>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>> On 9/17/22 9:38 PM, olcott wrote:
>>>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:31
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:54 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 5:42
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:08 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> September 16, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-7,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of Hx Once again - what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully study every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly decides that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that SOME
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that none
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create Px's
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was valid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> logic to see
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wouldn't go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a liar when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I SAY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that YOU are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the one lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input forever,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0, as implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct but the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mutually exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulationg Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deciders ARENT'T *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sets of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is. Or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even what a computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which ONE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does this based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matching
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> element of set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have TWO DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just lying or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something to be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given algorithm must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual operations
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of correctly matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "encodings" are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a SET OF DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we have deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different computaiton
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_loop are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your generic set you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hasn't proven by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with YOUR definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 that does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just as there NEVER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that give a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to comprehend the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of complete simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are defining that only the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in a finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider HH(Px,Px)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understands it understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> omits a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially" showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thinking that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5] 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5] 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777] 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1] 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1] 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777] 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion() is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes categorically exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attention, here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer >
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5 is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls, you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> get the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointing out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid mistakes"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset) FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THUS KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from, a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s? That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves my
>>>>>>>>>>>>>>>>>>>>>>>>>>>> point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational
>>>>>>>>>>>>>>>>>>>>>>>>>>> code, it's a pretty safe bet that you will
>>>>>>>>>>>>>>>>>>>>>>>>>>> not actually run it and answer the following
>>>>>>>>>>>>>>>>>>>>>>>>>>> two questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>> pairs contained in my project are named H/P
>>>>>>>>>>>>>>>>>>>>>>>>>> and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>>>> is directly executed it directly executes
>>>>>>>>>>>>>>>>>>>>>>>>>> Px(Px) that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter that it makes a Px that is
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting. That Hx FAILS just like you FAIL
>>>>>>>>>>>>>>>>>>>>>>>>> at being a correct decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0 does
>>>>>>>>>>>>>>>>>>>>>>>> this on the basis that it correctly matched a
>>>>>>>>>>>>>>>>>>>>>>>> correct infinite behavior pattern that correctly
>>>>>>>>>>>>>>>>>>>>>>>> proves that no Px element of the Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown to
>>>>>>>>>>>>>>>>>>>>>>> be incorrect, as the P(P) based on the H that
>>>>>>>>>>>>>>>>>>>>>>> uses it is Halting BECAUSE H matched its
>>>>>>>>>>>>>>>>>>>>>>> simulation to that pattern.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it proves
>>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers
>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they
>>>>>>>>>>>>>>>>>>> are answering the wrong question.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution
>>>>>>>>>>>>>>>>>> of Px(Px);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its direct
>>>>>>>>>>>>>>>>>> execution of its input, every Hx returning 0 does that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME
>>>>>>>>>>>>>>>>> the behavior of its direct execution of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for the
>>>>>>>>>>>>>>> Px built on it also creates a Px that when computing
>>>>>>>>>>>>>>> Px(Px) will halt in finite time since a simplified (but
>>>>>>>>>>>>>>> still correct) trace of Px(Px) would be:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px)
>>>>>>>>>>>>>>> will halt when computing Px(Px), that Hx is NOT correct
>>>>>>>>>>>>>>> to return 0.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A halt decider must predict what the behavior of its
>>>>>>>>>>>>>>>> input would be in the hypothetical case that it directly
>>>>>>>>>>>>>>>> executed its input. The means for it to do this are
>>>>>>>>>>>>>>>> unspecified, thus unconstrained:
>>>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, but it needs to give an answer in finite time, and
>>>>>>>>>>>>>>> the RIGHT answer to be correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This decider correctly determines that its direct
>>>>>>>>>>>>>> execution of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>>>> input would be (see above)
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>     return 0;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>>>
>>>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>>>
>>>>>>>>> So Px isn't calling it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> A halt decider must always determine whether or not its direct
>>>>>>>> execution of its input would halt if it directly executed this
>>>>>>>> input and it must do this without actually directly executing it:
>>>>>>>> (a) Static analysis
>>>>>>>> (b) Partial simulation
>>>>>>>> (c) Wild guess
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>>>
>>>>>>> YOU FAIL.
>>>>>>>
>>>>>>> NO WHERE does the definition talk about deciding about *IT* doing
>>>>>>> a direct exectution.
>>>>>>>
>>>>>>
>>>>>> So you acknowledge that when Hx would directly execute its input
>>>>>> that this directly executed input would never halt?
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> If Hx DOES directly execute its input, then it will NEVER report
>>>>> non-halting, and yes, then the input Px built from THAT Hx will be
>>>>> non-halting.
>>>>>
>>>>
>>>> Then you also agree that another instance of Hx(Px,Px) that reports
>>>> on what the behavior of its direct execution of its input would be
>>>> if it did a direct execution of this input would be correct to
>>>> return 0?
>>>>
>>>
>>> Another instance of that Hx CAN'T report that result, as it can only
>>> just execute its input, as that is what its algorithm says to do.
>>
>>
>> This instance of Hx(Px,Px) correctly reports its direct
>> execution of its input never halts:
>>
>> int Hx(ptr x, ptr y)
>> {
>>    return 0;
>> }
>>
>
> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>
On 9/17/2022 9:38 PM, Richard Damon wrote:
> If Hx DOES directly execute its input, then it will NEVER report
> non-halting, and yes, then the input Px built from THAT Hx will be
> non-halting.


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<BHHVK.547346$BKL8.25399@fx15.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!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!fx15.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me>
<f969ee83-2fbc-4873-a8f9-420e5a802773n@googlegroups.com>
<tg5ah7$7qia$5@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7ct1$iutf$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 1201
Message-ID: <BHHVK.547346$BKL8.25399@fx15.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 12:29:20 -0400
X-Received-Bytes: 76355
 by: Richard Damon - Sun, 18 Sep 2022 16:29 UTC

On 9/18/22 11:18 AM, olcott wrote:
> On 9/18/2022 6:27 AM, Richard Damon wrote:
>> On 9/18/22 12:12 AM, olcott wrote:
>>> On 9/17/2022 10:19 PM, Richard Damon wrote:
>>>> On 9/17/22 10:52 PM, olcott wrote:
>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>> On 9/17/22 9:38 PM, olcott wrote:
>>>>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24
>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:31
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:54 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:42 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:08 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday, September
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 16,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-7,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> =
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(x,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goto
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Once
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> - what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> study
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SOME of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that none
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was valid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop wouldn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have proven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a liar when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SAY THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that YOU are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the one lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input forever,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0, as implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> two mutually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulationg Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deciders ARENT'T *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sets of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is. Or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ONE is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it does this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> element of set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have TWO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just lying or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something to be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given algorithm must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "encodings" are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually a SET OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computaiton giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_loop are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contained in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your generic set you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hasn't proven by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with YOUR
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition, as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H0 that does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just as there NEVER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that give a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to comprehend
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of complete simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are defining that only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in a finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider HH(Px,Px)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understands it understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> omits a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showing youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thinking that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion() is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same arguments
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes categorically exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attention, here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > 5 is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of every instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls, you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> get the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben pointed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointing out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes" are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset) FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THUS KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from, a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px, and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s? That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus anyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> my point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational
>>>>>>>>>>>>>>>>>>>>>>>>>>>> code, it's a pretty safe bet that you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>> not actually run it and answer the following
>>>>>>>>>>>>>>>>>>>>>>>>>>>> two questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs contained in my project are named H/P
>>>>>>>>>>>>>>>>>>>>>>>>>>> and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs is directly executed it directly
>>>>>>>>>>>>>>>>>>>>>>>>>>> executes Px(Px) that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it
>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter that it makes a Px that is
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting. That Hx FAILS just like you FAIL
>>>>>>>>>>>>>>>>>>>>>>>>>> at being a correct decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0
>>>>>>>>>>>>>>>>>>>>>>>>> does this on the basis that it correctly
>>>>>>>>>>>>>>>>>>>>>>>>> matched a correct infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>> that correctly proves that no Px element of the
>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px pairs simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown to
>>>>>>>>>>>>>>>>>>>>>>>> be incorrect, as the P(P) based on the H that
>>>>>>>>>>>>>>>>>>>>>>>> uses it is Halting BECAUSE H matched its
>>>>>>>>>>>>>>>>>>>>>>>> simulation to that pattern.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it proves
>>>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers
>>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they
>>>>>>>>>>>>>>>>>>>> are answering the wrong question.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution
>>>>>>>>>>>>>>>>>>> of Px(Px);
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its
>>>>>>>>>>>>>>>>>>> direct execution of its input, every Hx returning 0
>>>>>>>>>>>>>>>>>>> does that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME
>>>>>>>>>>>>>>>>>> the behavior of its direct execution of its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for the
>>>>>>>>>>>>>>>> Px built on it also creates a Px that when computing
>>>>>>>>>>>>>>>> Px(Px) will halt in finite time since a simplified (but
>>>>>>>>>>>>>>>> still correct) trace of Px(Px) would be:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px)
>>>>>>>>>>>>>>>> will halt when computing Px(Px), that Hx is NOT correct
>>>>>>>>>>>>>>>> to return 0.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A halt decider must predict what the behavior of its
>>>>>>>>>>>>>>>>> input would be in the hypothetical case that it
>>>>>>>>>>>>>>>>> directly executed its input. The means for it to do
>>>>>>>>>>>>>>>>> this are unspecified, thus unconstrained:
>>>>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, but it needs to give an answer in finite time,
>>>>>>>>>>>>>>>> and the RIGHT answer to be correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This decider correctly determines that its direct
>>>>>>>>>>>>>>> execution of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a LIE.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>>>>> input would be (see above)
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>     return 0;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>>>>
>>>>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>>>>
>>>>>>>>>> So Px isn't calling it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> A halt decider must always determine whether or not its direct
>>>>>>>>> execution of its input would halt if it directly executed this
>>>>>>>>> input and it must do this without actually directly executing it:
>>>>>>>>> (a) Static analysis
>>>>>>>>> (b) Partial simulation
>>>>>>>>> (c) Wild guess
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>>>>
>>>>>>>> YOU FAIL.
>>>>>>>>
>>>>>>>> NO WHERE does the definition talk about deciding about *IT*
>>>>>>>> doing a direct exectution.
>>>>>>>>
>>>>>>>
>>>>>>> So you acknowledge that when Hx would directly execute its input
>>>>>>> that this directly executed input would never halt?
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> If Hx DOES directly execute its input, then it will NEVER report
>>>>>> non-halting, and yes, then the input Px built from THAT Hx will be
>>>>>> non-halting.
>>>>>>
>>>>>
>>>>> Then you also agree that another instance of Hx(Px,Px) that reports
>>>>> on what the behavior of its direct execution of its input would be
>>>>> if it did a direct execution of this input would be correct to
>>>>> return 0?
>>>>>
>>>>
>>>> Another instance of that Hx CAN'T report that result, as it can only
>>>> just execute its input, as that is what its algorithm says to do.
>>>
>>>
>>> This instance of Hx(Px,Px) correctly reports its direct
>>> execution of its input never halts:
>>>
>>> int Hx(ptr x, ptr y)
>>> {
>>>    return 0;
>>> }
>>>
>>
>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>
> On 9/17/2022 9:38 PM, Richard Damon wrote:
> > If Hx DOES directly execute its input, then it will NEVER report
> > non-halting, and yes, then the input Px built from THAT Hx will be
> > non-halting.
>
>


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7itp$kb3u$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 12:01:44 -0500
Organization: A noiseless patient Spider
Lines: 1153
Message-ID: <tg7itp$kb3u$1@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <tg5ah7$7qia$5@dont-email.me>
<1gqVK.108733$elEa.29588@fx09.iad> <tg5c0b$13po$1@gioia.aioe.org>
<PLqVK.544439$BKL8.489773@fx15.iad> <tg5ei8$8g1j$1@dont-email.me>
<tdrVK.119005$479c.102129@fx48.iad> <tg5g4d$8g1j$3@dont-email.me>
<KHrVK.119006$479c.105120@fx48.iad> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 17:01:45 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="666750"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/427LosAC6mnV5klBVfB/4"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:j5yXJcAGihbBzjOpoib2dWSFQLk=
In-Reply-To: <BHHVK.547346$BKL8.25399@fx15.iad>
Content-Language: en-US
 by: olcott - Sun, 18 Sep 2022 17:01 UTC

On 9/18/2022 11:29 AM, Richard Damon wrote:
> On 9/18/22 11:18 AM, olcott wrote:
>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>> On 9/18/22 12:12 AM, olcott wrote:
>>>> On 9/17/2022 10:19 PM, Richard Damon wrote:
>>>>> On 9/17/22 10:52 PM, olcott wrote:
>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>> On 9/17/22 9:38 PM, olcott wrote:
>>>>>>>> On 9/17/2022 8:12 PM, Richard Damon wrote:
>>>>>>>>> On 9/17/22 9:02 PM, olcott wrote:
>>>>>>>>>> On 9/17/2022 7:27 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/17/22 8:08 PM, olcott wrote:
>>>>>>>>>>>> On 9/17/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/17/22 7:45 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/17/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/17/22 7:28 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/17/2022 6:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/17/22 6:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/17/2022 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/17/22 6:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/17/2022 5:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/17/22 6:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 5:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at 9:12:24
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 1:13 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:16:46 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 12:03 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 17, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:07:40 PM UTC+1, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/2022 6:06 AM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 10:56 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:33 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 10:17 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 9:07 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 9:55 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 8:29 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:50 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:30 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 8:21 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 7:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:45 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 6:40
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 7:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 5:58
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:45
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:31 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22 6:11
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:54 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:42 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5:18 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:06 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4:22 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022 3:08 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/22
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:36
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9/16/2022 2:04 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Friday, September 16, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 9:17:21 AM UTC-7, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nothing without a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of Hx Once again - what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying to prove?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> carefully study every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include an infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions of Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly decides that Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SOME of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partially or fully simulated Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRECISELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then every Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But an Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> member of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> create
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px's that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have ZERO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was valid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equally to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> issue is that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU are not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> noticing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to see that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop wouldn't go on forever, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have proven
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unequivocally a liar when you say that an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WHERE DID I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SAY THAT?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Seems to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that YOU are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the one lying,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of H0 that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compuation as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0, as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implied by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The conclusion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the wording is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> illogical.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 either does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> two mutually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exclusive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> categories for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elements of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 where H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulationg Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deciders ARENT'T *A*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sets of them?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That means you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Or even what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computater
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point. (b) Never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input at any point.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, so which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ONE is H0?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Please write a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SET.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You clearly don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROGRAM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H0 returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 it does this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, appearently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have TWO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT H0's,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0a, an H0b.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Did I stutter?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, apparently you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are just lying or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your stupidity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what a computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what is required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for something to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the set of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All "Encodings" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a given algorithm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must behave
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same, if all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is varying is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Encoding" (the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> symbolic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations) and not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operations that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are performed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I dop remember you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dropping out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that class
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before you got to it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A subset of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encodings of H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that return 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do so on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "encodings" are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually "encodings"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actaul
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementations of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic algorithm.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus you have a set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of SPECIIF ALGORITHMS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A decider must be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SPECIFIC ALGORITHM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> variations on a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually a SET OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DECIDERS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it IS correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders H0a and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0b as DIFFERENT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders since they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implement a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computaiton giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H0 and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_loop are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> various halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contained in Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> currently only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> compiles under:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And note, that H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is just a SPEICIIFIC
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your generic set
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't meet your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements, as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never completely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulatutes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hasn't proven by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (It may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that input being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual definition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows the problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with YOUR
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition, as there
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no H0 that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H0 that does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the required
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, just as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there NEVER is for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders that give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you consistently
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to comprehend
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that accurately
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They CAN exist, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't allow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for their use, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are defining that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern in a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if it did perform
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But there is no pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match in a finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, so your H can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correctly determine" that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider HH(Px,Px)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input it can see that:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Function HH(Px,Px)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of Px().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments to HH(Px,Px).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of Px() and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its call to HH(Px,Px) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated simulations.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that isn't proof of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Non-Halting. Care to try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually show a reliable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference that claims it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (not from you()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that fully
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understands it understands
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> essentially the same proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly detects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. I am
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not giving up on you because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did recently correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand and acknowledge a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> key element of another proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it isn't, because it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> omits a key part of the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are "essentially"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showing youself to be a total
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idiot and clueless about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) Halts, it CAN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be correct and you show your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lack of intelegence in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thinking that it could be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:111fe5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fd1][00111fd5] 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fd1][00111fd5] 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fd1][00111fd5] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fcd][00000777] 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f2][00111fc5][00111fd1] 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f3][00111fc5][00111fd1] 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f5][00111fc5][00111fd1] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f8][00111fc1][00000777] 50 push eax // push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0x777
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call Infinite_Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H: Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is called twice in sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() .
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) With the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) With no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion() from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FALLACY OF PROOF BY EXAMPLES.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROOF OF YOUR STUPIDITY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A proof by example (over
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generalization) is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fallacy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it includes the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of every possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> example. In this case it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning (CAR)**.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Really? Your ONE example is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even showing an infinte
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of examples isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exahustive since we can show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infintie number of cases
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you did NOT look at.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not pay enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attention, here is what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *the infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible example*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can know that every integer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > 5 is also > 3 without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> checking each one.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has zero false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> positives across the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x(y); // is P(P) when Hx(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is invoked.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above Hx is one element of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But not the one that *THE* P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls, you know, the one that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the H that is supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> get the right answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above one is the one that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must report on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you agreed with a key
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point recently I am confident
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can have an actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if you are willing to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change an be HONEST.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always been honest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Even in the case that Ben
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointed out when I claimed that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> had two Turing machines and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead had something
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computationally equivalent to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> two Turing machines. In other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words for all practical purposes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I did have two Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines, thus close enough.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So far it has just been me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointing out your stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of my recent "stupid
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistakes" are merely your lack of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehension of my difficult
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ideas.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, Programs/Machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't call/use "Sets" of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program/machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Set theory is how categorically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exhaustive reasoning is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all X are Y then anything
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that says all X are Y is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct. (All male
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans are humans).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If all correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px by Hx never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt then when some Hx returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning that all correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulations of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt then these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instances of Hx are necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the sub-set of all correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete simulations is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as the set of all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations of Px, so you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown that ALL Px will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We began with all of the *partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or complete* simulations of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Understanding the above code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves this*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are zero elements of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite set of Hx/Px pairs such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct *partial or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete* simulation of Px by Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we took a subset of this set:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS (as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subset) FROM ABOVE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (A) Every element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of Hx/Px pairs that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does a correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *THIS IS THE DEFINITION OF A UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THUS KNOWN TO BE TRUE*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (B) A correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of Px by Hx derives the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you fail at knowing set theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> too.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No I just proved that you weren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> paying enough attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you explain why you have gone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from, a couple of weeks ago,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming you had a single Hx which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> worked, to now talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite set of Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard kept saying that H does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine the halt status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct sequence of instructions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> so I proved that Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines the correct halts status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for all sequences of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions where Px is simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So he said you were using the wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px, and you respond by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throwing in infinitely more Hx s?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That makes no sense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All male humans are humans, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyone saying that male humans are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every Px simulated by Hx never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus every Hx saying that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> every Px simulated by Hx never halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason every Px simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx never halts is because Hx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, you are indeed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have fully operational code that proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> my point all you have is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incoherent misconceptions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Complete halt deciding system including*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *(c) All of the various halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs are contained in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> While you claim to have fully operational
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code, it's a pretty safe bet that you will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not actually run it and answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> following two questions about it:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The elements of the infinite set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs contained in my project are named H/P
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and HH/PP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You will dishonestly say I've changed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject, or some similar feeble excuse.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When this Hx element of the set of Hx/Px
>>>>>>>>>>>>>>>>>>>>>>>>>>>> pairs is directly executed it directly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> executes Px(Px) that never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So, that Hx never gives an answer, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter that it makes a Px that is
>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting. That Hx FAILS just like you FAIL
>>>>>>>>>>>>>>>>>>>>>>>>>>> at being a correct decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> At least one of the Hx elements returning 0
>>>>>>>>>>>>>>>>>>>>>>>>>> does this on the basis that it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> matched a correct infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>> that correctly proves that no Px element of
>>>>>>>>>>>>>>>>>>>>>>>>>> the Hx/Px pairs simulated by Hx halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which one?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> What is that CORRECT pattern?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Remenber, your CLAIMED pattern has been shown
>>>>>>>>>>>>>>>>>>>>>>>>> to be incorrect, as the P(P) based on the H
>>>>>>>>>>>>>>>>>>>>>>>>> that uses it is Halting BECAUSE H matched its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation to that pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When H(P,P) directly executes its input it
>>>>>>>>>>>>>>>>>>>>>>>> proves that P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Except that *THE* P that was built from the H you
>>>>>>>>>>>>>>>>>>>>>>> claimed was giving the right answer, not one that
>>>>>>>>>>>>>>>>>>>>>>> doesn't.
>>>>>>>>>>>>>>>>>>>>>> Every Hx element that returns 0 correctly answers
>>>>>>>>>>>>>>>>>>>>>> the question:
>>>>>>>>>>>>>>>>>>>>>> Does any Px element correctly simulated by Hx halt?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This same reasoning applies to H/P pairs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So none of your Hx are Halt Deciders, because they
>>>>>>>>>>>>>>>>>>>>> are answering the wrong question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    x(y); // Hx(Px,Px) specifies the direct execution
>>>>>>>>>>>>>>>>>>>> of Px(Px);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A halt decider must predict the behavior of its
>>>>>>>>>>>>>>>>>>>> direct execution of its input, every Hx returning 0
>>>>>>>>>>>>>>>>>>>> does that.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not quite, A Halt Decider must prdicit IN FINITE TIME
>>>>>>>>>>>>>>>>>>> the behavior of its direct execution of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above Hx doesn't do that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yet every Hx that returns 0 *DOES DO THAT*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Really? So are you admitting that the above Hx isn't a
>>>>>>>>>>>>>>>>> correct Halt Decider?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And since ANY Hx that returns a 0 from Hx(Px,Px) for
>>>>>>>>>>>>>>>>> the Px built on it also creates a Px that when
>>>>>>>>>>>>>>>>> computing Px(Px) will halt in finite time since a
>>>>>>>>>>>>>>>>> simplified (but still correct) trace of Px(Px) would be:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Enter Px
>>>>>>>>>>>>>>>>> Call Hx(Px,Px)
>>>>>>>>>>>>>>>>> After finite time, Hx returns 0
>>>>>>>>>>>>>>>>> Px test the return value.
>>>>>>>>>>>>>>>>> Since 0, Halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus ALL Px based on a Hx that returns 0 for Hx(Px,Px)
>>>>>>>>>>>>>>>>> will halt when computing Px(Px), that Hx is NOT correct
>>>>>>>>>>>>>>>>> to return 0.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A halt decider must predict what the behavior of its
>>>>>>>>>>>>>>>>>> input would be in the hypothetical case that it
>>>>>>>>>>>>>>>>>> directly executed its input. The means for it to do
>>>>>>>>>>>>>>>>>> this are unspecified, thus unconstrained:
>>>>>>>>>>>>>>>>>> (a) Static analysis
>>>>>>>>>>>>>>>>>> (b) Partial simulation
>>>>>>>>>>>>>>>>>> (c) Wild guess
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, but it needs to give an answer in finite time,
>>>>>>>>>>>>>>>>> and the RIGHT answer to be correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This decider correctly determines that its direct
>>>>>>>>>>>>>>>> execution of its input Hx(Px,Px) would never halt:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Execpt that it isn't CORRECT, so you statement is just a
>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Trace of the Direct Exectuion of its input, the input to
>>>>>>>>>>>>>>> Hx(Px,Px)
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    x(y); // the direct execution of the input to Hx(Px,Px)
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // correctly reporting on what the direct execution of its
>>>>>>>>>>>>>> input would be (see above)
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>     return 0;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> ERROR: DUPLICATE SYMBOLS
>>>>>>>>>>>>>
>>>>>>>>>>>> I already explained that the first one is hypothetical.
>>>>>>>>>>>
>>>>>>>>>>> So Px isn't calling it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A halt decider must always determine whether or not its direct
>>>>>>>>>> execution of its input would halt if it directly executed this
>>>>>>>>>> input and it must do this without actually directly executing it:
>>>>>>>>>> (a) Static analysis
>>>>>>>>>> (b) Partial simulation
>>>>>>>>>> (c) Wild guess
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, you don't understand what a Halt Decider is.
>>>>>>>>>
>>>>>>>>> YOU FAIL.
>>>>>>>>>
>>>>>>>>> NO WHERE does the definition talk about deciding about *IT*
>>>>>>>>> doing a direct exectution.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So you acknowledge that when Hx would directly execute its input
>>>>>>>> that this directly executed input would never halt?
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> If Hx DOES directly execute its input, then it will NEVER report
>>>>>>> non-halting, and yes, then the input Px built from THAT Hx will
>>>>>>> be non-halting.
>>>>>>>
>>>>>>
>>>>>> Then you also agree that another instance of Hx(Px,Px) that
>>>>>> reports on what the behavior of its direct execution of its input
>>>>>> would be if it did a direct execution of this input would be
>>>>>> correct to return 0?
>>>>>>
>>>>>
>>>>> Another instance of that Hx CAN'T report that result, as it can
>>>>> only just execute its input, as that is what its algorithm says to do.
>>>>
>>>>
>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>> execution of its input never halts:
>>>>
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>>    return 0;
>>>> }
>>>>
>>>
>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>
>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>  > If Hx DOES directly execute its input, then it will NEVER report
>>  > non-halting, and yes, then the input Px built from THAT Hx will be
>>  > non-halting.
>>
>>
>
> And since Hx doesn't directly execute its input,
Its basis for correctly deciding that the direct execution of this input
would never halt is a wild guess.


Click here to read the complete article
Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<puIVK.295043$wLZ8.84102@fx18.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5ah7$7qia$5@dont-email.me>
<1gqVK.108733$elEa.29588@fx09.iad> <tg5c0b$13po$1@gioia.aioe.org>
<PLqVK.544439$BKL8.489773@fx15.iad> <tg5ei8$8g1j$1@dont-email.me>
<tdrVK.119005$479c.102129@fx48.iad> <tg5g4d$8g1j$3@dont-email.me>
<KHrVK.119006$479c.105120@fx48.iad> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7itp$kb3u$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 63
Message-ID: <puIVK.295043$wLZ8.84102@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: Sun, 18 Sep 2022 13:23:32 -0400
X-Received-Bytes: 4014
 by: Richard Damon - Sun, 18 Sep 2022 17:23 UTC

On 9/18/22 1:01 PM, olcott wrote:
> On 9/18/2022 11:29 AM, Richard Damon wrote:
>> On 9/18/22 11:18 AM, olcott wrote:
>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>> execution of its input never halts:
>>>>>
>>>>> int Hx(ptr x, ptr y)
>>>>> {
>>>>>    return 0;
>>>>> }
>>>>>
>>>>
>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>
>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>  > If Hx DOES directly execute its input, then it will NEVER report
>>>  > non-halting, and yes, then the input Px built from THAT Hx will be
>>>  > non-halting.
>>>
>>>
>>
>> And since Hx doesn't directly execute its input,
> Its basis for correctly deciding that the direct execution of this input
> would never halt is a wild guess.

So, it guesses wrong about the actual question that is being asked of it.

You CAN'T ask about the behavior of something that doesn't happen.

>
> Another version could correctly match (in a finite number of simulated
> steps) an adapted version of the correct infinite recursion behavior
> pattern to correctly determine that no correct simulation of Px by Hx
> ever reaches a final state of Px and halts.
>
>

So, you don't understand that the input SPECIFIES what "version" of Hx
it is calling (or needs to in order to match the definitions of
computations).

If you change the Hx that Px calls, that is like replying when asked
"How many cats do you have?", if you have 2 cats and 1 dog, with the
answer 1 and saying that is the correct answer, as it would be if you
asked about how many dogs you have.

You are just PROVING your ignorance of the subject.

The Halt Decider needs to answer about the ACTUAL behavior of its ACTUAL
input, not some hypothetical behavior of some imagined alternate input
that is different from the one specifed.

You are just showing you don't believe in the truth, but are stuck in
your LIES.

You have dug yourself, and you reputation, a hole so deep I don't think
you can get yourself out of it.

YOU HAVE FAILED.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7kfe$kb3u$3@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 12:28:13 -0500
Organization: A noiseless patient Spider
Lines: 43
Message-ID: <tg7kfe$kb3u$3@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <1gqVK.108733$elEa.29588@fx09.iad>
<tg5c0b$13po$1@gioia.aioe.org> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 17:28:14 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="666750"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19OCDav77GPBzPD/1bg+voh"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:QIM4h3mzB7RSrvof+632LpW9R4Q=
In-Reply-To: <puIVK.295043$wLZ8.84102@fx18.iad>
Content-Language: en-US
 by: olcott - Sun, 18 Sep 2022 17:28 UTC

On 9/18/2022 12:23 PM, Richard Damon wrote:
>
> On 9/18/22 1:01 PM, olcott wrote:
>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>> On 9/18/22 11:18 AM, olcott wrote:
>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>> execution of its input never halts:
>>>>>>
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>>    return 0;
>>>>>> }
>>>>>>
>>>>>
>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>
>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>  > If Hx DOES directly execute its input, then it will NEVER report
>>>>  > non-halting, and yes, then the input Px built from THAT Hx will be
>>>>  > non-halting.
>>>>
>>>>
>>>
>>> And since Hx doesn't directly execute its input,
>> Its basis for correctly deciding that the direct execution of this
>> input would never halt is a wild guess.
>
> So, it guesses wrong about the actual question that is being asked of it.
>
Why do I have to tell you the same thing 500 times and you still don't
get it? My theory is that you are a liar only interested in rebuttal.

No halt decider ever directly executes its input yet must correctly
predict the behavior of this directly executed or correctly simulated
input.

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<XHIVK.295044$wLZ8.42432@fx18.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5c0b$13po$1@gioia.aioe.org>
<PLqVK.544439$BKL8.489773@fx15.iad> <tg5ei8$8g1j$1@dont-email.me>
<tdrVK.119005$479c.102129@fx48.iad> <tg5g4d$8g1j$3@dont-email.me>
<KHrVK.119006$479c.105120@fx48.iad> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7kfe$kb3u$3@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 71
Message-ID: <XHIVK.295044$wLZ8.42432@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: Sun, 18 Sep 2022 13:37:59 -0400
X-Received-Bytes: 4245
 by: Richard Damon - Sun, 18 Sep 2022 17:37 UTC

On 9/18/22 1:28 PM, olcott wrote:
> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>
>> On 9/18/22 1:01 PM, olcott wrote:
>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>> execution of its input never halts:
>>>>>>>
>>>>>>> int Hx(ptr x, ptr y)
>>>>>>> {
>>>>>>>    return 0;
>>>>>>> }
>>>>>>>
>>>>>>
>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>
>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>  > If Hx DOES directly execute its input, then it will NEVER report
>>>>>  > non-halting, and yes, then the input Px built from THAT Hx will be
>>>>>  > non-halting.
>>>>>
>>>>>
>>>>
>>>> And since Hx doesn't directly execute its input,
>>> Its basis for correctly deciding that the direct execution of this
>>> input would never halt is a wild guess.
>>
>> So, it guesses wrong about the actual question that is being asked of it.
>>
> Why do I have to tell you the same thing 500 times and you still don't
> get it?  My theory is that you are a liar only interested in rebuttal.
>
> No halt decider ever directly executes its input yet must correctly
> predict the behavior of this directly executed or correctly simulated
> input.
>

Right, THE behavior of direct execution or correct simulation, not by
the decider, but just done.

If you want to add the words "by the decider", you need a source for
that, which you have failed to do.

If the simulator doesn't do that, then you can't assume that it does,
and thus can't impose that behavior of copies of it used in the input.

H(P,P) returning 0 is INCORRECT because P(P) will Halt if H(P,P) returns
0, as will UTM(P,P).

THAT IS A FACT, and you have even agreed to the fact that P(P) and
UTM(P,P) will halt.

BY YOUR DEFINITION HERE, the decider must correctly predict the behavior
of the directly executed or correctly simulated input.

THAT IS HALTING, BY YOUR OWN ADMISSION.

Thus, H(PP) is WRONG to say non-halting, and you are shown to be just
lying to say it is right,

YOU ARE PROVING YOURSELF TO BE A LIAR.

YOU HAVE DUG YOUR OWN GRAVE for your reputation and your logic.

YOU HAVE FAILED.

Sorry you have done this to yourself.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7le7$kb3u$4@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 12:44:39 -0500
Organization: A noiseless patient Spider
Lines: 58
Message-ID: <tg7le7$kb3u$4@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <PLqVK.544439$BKL8.489773@fx15.iad>
<tg5ei8$8g1j$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 17:44:39 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="666750"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/3OMBtxpVxpBsXHZCDBeKa"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:qq65rFXGdSQbqyvIVpqrls2QBzY=
Content-Language: en-US
In-Reply-To: <XHIVK.295044$wLZ8.42432@fx18.iad>
 by: olcott - Sun, 18 Sep 2022 17:44 UTC

On 9/18/2022 12:37 PM, Richard Damon wrote:
>
> On 9/18/22 1:28 PM, olcott wrote:
>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>
>>> On 9/18/22 1:01 PM, olcott wrote:
>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>> execution of its input never halts:
>>>>>>>>
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>>    return 0;
>>>>>>>> }
>>>>>>>>
>>>>>>>
>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>>
>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>  > If Hx DOES directly execute its input, then it will NEVER report
>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx will be
>>>>>>  > non-halting.
>>>>>>
>>>>>>
>>>>>
>>>>> And since Hx doesn't directly execute its input,
>>>> Its basis for correctly deciding that the direct execution of this
>>>> input would never halt is a wild guess.
>>>
>>> So, it guesses wrong about the actual question that is being asked of
>>> it.
>>>
>> Why do I have to tell you the same thing 500 times and you still don't
>> get it?  My theory is that you are a liar only interested in rebuttal.
>>
>> No halt decider ever directly executes its input yet must correctly
>> predict the behavior of this directly executed or correctly simulated
>> input.
>>
>
> Right, THE behavior of direct execution or correct simulation, not by
> the decider, but just done.
>
> If you want to add the words "by the decider", you need a source for
> that, which you have failed to do.

First you must agree that every Hx returning 0 does correctly report the
halt status of the behavior of what its direct execution of Px(Px) would
be if it directly executed this input.

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<PSIVK.36387$ocy7.6704@fx38.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5ei8$8g1j$1@dont-email.me>
<tdrVK.119005$479c.102129@fx48.iad> <tg5g4d$8g1j$3@dont-email.me>
<KHrVK.119006$479c.105120@fx48.iad> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
<XHIVK.295044$wLZ8.42432@fx18.iad> <tg7le7$kb3u$4@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7le7$kb3u$4@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 75
Message-ID: <PSIVK.36387$ocy7.6704@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 13:49:35 -0400
X-Received-Bytes: 4638
 by: Richard Damon - Sun, 18 Sep 2022 17:49 UTC

On 9/18/22 1:44 PM, olcott wrote:
> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>
>> On 9/18/22 1:28 PM, olcott wrote:
>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>
>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>> execution of its input never halts:
>>>>>>>>>
>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>> {
>>>>>>>>>    return 0;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>>>
>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER report
>>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx
>>>>>>> will be
>>>>>>>  > non-halting.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And since Hx doesn't directly execute its input,
>>>>> Its basis for correctly deciding that the direct execution of this
>>>>> input would never halt is a wild guess.
>>>>
>>>> So, it guesses wrong about the actual question that is being asked
>>>> of it.
>>>>
>>> Why do I have to tell you the same thing 500 times and you still
>>> don't get it?  My theory is that you are a liar only interested in
>>> rebuttal.
>>>
>>> No halt decider ever directly executes its input yet must correctly
>>> predict the behavior of this directly executed or correctly simulated
>>> input.
>>>
>>
>> Right, THE behavior of direct execution or correct simulation, not by
>> the decider, but just done.
>>
>> If you want to add the words "by the decider", you need a source for
>> that, which you have failed to do.
>
> First you must agree that every Hx returning 0 does correctly report the
> halt status of the behavior of what its direct execution of Px(Px) would
> be if it directly executed this input.
>

No. because no Hx that does a direct execution even gives an answer, so
your statement is ILLOGICAL.

That means that if Hx is returning an answer, Px doesn't call an Hx that
does a direct execution of its input, since Px is DEFINED to call the Hx
that is claimed to give the right answer for it.

You are thus shown to be LYING that its answer is correct, because it
has been showns that ANY Px that calls an Hx that returns 0 from
Hx(Px,Px) will halt, and thus 0 is NOT the correct answer.

The fact that you make such a demand shows that you are ignorant of what
you are talking about, and just trying to practice (poorly) deception.

That shows how idiotic you are, and how stupid, that you would even
think that people would beleive you.

FAIL.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7lt7$kb3u$5@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 12:52:39 -0500
Organization: A noiseless patient Spider
Lines: 69
Message-ID: <tg7lt7$kb3u$5@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <tdrVK.119005$479c.102129@fx48.iad>
<tg5g4d$8g1j$3@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 17:52:39 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="666750"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+49OgUrvG27a1wjhi0CPDS"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:50LeeZghPS/1W4fgmjOqGWxzjAE=
Content-Language: en-US
In-Reply-To: <PSIVK.36387$ocy7.6704@fx38.iad>
 by: olcott - Sun, 18 Sep 2022 17:52 UTC

On 9/18/2022 12:49 PM, Richard Damon wrote:
> On 9/18/22 1:44 PM, olcott wrote:
>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>
>>> On 9/18/22 1:28 PM, olcott wrote:
>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>    return 0;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>>>>
>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER report
>>>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx
>>>>>>>> will be
>>>>>>>>  > non-halting.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And since Hx doesn't directly execute its input,
>>>>>> Its basis for correctly deciding that the direct execution of this
>>>>>> input would never halt is a wild guess.
>>>>>
>>>>> So, it guesses wrong about the actual question that is being asked
>>>>> of it.
>>>>>
>>>> Why do I have to tell you the same thing 500 times and you still
>>>> don't get it?  My theory is that you are a liar only interested in
>>>> rebuttal.
>>>>
>>>> No halt decider ever directly executes its input yet must correctly
>>>> predict the behavior of this directly executed or correctly
>>>> simulated input.
>>>>
>>>
>>> Right, THE behavior of direct execution or correct simulation, not by
>>> the decider, but just done.
>>>
>>> If you want to add the words "by the decider", you need a source for
>>> that, which you have failed to do.
>>
>> First you must agree that every Hx returning 0 does correctly report
>> the halt status of the behavior of what its direct execution of Px(Px)
>> would be if it directly executed this input.
>>
>
> No. because no Hx that does a direct execution even gives an answer, so
> your statement is ILLOGICAL.
Halt deciders are not supposed to do a direct execution and you know
this so what the Hell are you trying to pull here?

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<GZIVK.53332$SMP5.52260@fx05.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5g4d$8g1j$3@dont-email.me>
<KHrVK.119006$479c.105120@fx48.iad> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
<XHIVK.295044$wLZ8.42432@fx18.iad> <tg7le7$kb3u$4@dont-email.me>
<PSIVK.36387$ocy7.6704@fx38.iad> <tg7lt7$kb3u$5@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7lt7$kb3u$5@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 81
Message-ID: <GZIVK.53332$SMP5.52260@fx05.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 13:56:54 -0400
X-Received-Bytes: 4732
 by: Richard Damon - Sun, 18 Sep 2022 17:56 UTC

On 9/18/22 1:52 PM, olcott wrote:
> On 9/18/2022 12:49 PM, Richard Damon wrote:
>> On 9/18/22 1:44 PM, olcott wrote:
>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>
>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>
>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>    return 0;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>>>>>
>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER
>>>>>>>>> report
>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx
>>>>>>>>> will be
>>>>>>>>>  > non-halting.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>> this input would never halt is a wild guess.
>>>>>>
>>>>>> So, it guesses wrong about the actual question that is being asked
>>>>>> of it.
>>>>>>
>>>>> Why do I have to tell you the same thing 500 times and you still
>>>>> don't get it?  My theory is that you are a liar only interested in
>>>>> rebuttal.
>>>>>
>>>>> No halt decider ever directly executes its input yet must correctly
>>>>> predict the behavior of this directly executed or correctly
>>>>> simulated input.
>>>>>
>>>>
>>>> Right, THE behavior of direct execution or correct simulation, not
>>>> by the decider, but just done.
>>>>
>>>> If you want to add the words "by the decider", you need a source for
>>>> that, which you have failed to do.
>>>
>>> First you must agree that every Hx returning 0 does correctly report
>>> the halt status of the behavior of what its direct execution of
>>> Px(Px) would be if it directly executed this input.
>>>
>>
>> No. because no Hx that does a direct execution even gives an answer,
>> so your statement is ILLOGICAL.
> Halt deciders are not supposed to do a direct execution and you know
> this so what the Hell are you trying to pull here?
>

Right, the aren't supposed to so why do you think they need to act like
they did?

THAT is ILLOGICAL.

Your criteria of predicting what they would do if they were something
they can't be is ILLOGICAL, and utterly incorrect.

You are just showing your total ignorance of the field.

YOU HAVE FAILED

You have KILLED any reputation you might have had by your insane ideas,
and buried it under your lies.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7m93$kb3u$6@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 12:58:59 -0500
Organization: A noiseless patient Spider
Lines: 77
Message-ID: <tg7m93$kb3u$6@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
<tg7lt7$kb3u$5@dont-email.me> <GZIVK.53332$SMP5.52260@fx05.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 17:58:59 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="666750"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX184l/0gGMW1pvrDoduhgN5+"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:TK/DDfcYTJv03Uawu0HglPiDhQM=
Content-Language: en-US
In-Reply-To: <GZIVK.53332$SMP5.52260@fx05.iad>
 by: olcott - Sun, 18 Sep 2022 17:58 UTC

On 9/18/2022 12:56 PM, Richard Damon wrote:
> On 9/18/22 1:52 PM, olcott wrote:
>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>> On 9/18/22 1:44 PM, olcott wrote:
>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    return 0;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>>>>>>
>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER
>>>>>>>>>> report
>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx
>>>>>>>>>> will be
>>>>>>>>>>  > non-halting.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>> this input would never halt is a wild guess.
>>>>>>>
>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>> asked of it.
>>>>>>>
>>>>>> Why do I have to tell you the same thing 500 times and you still
>>>>>> don't get it?  My theory is that you are a liar only interested in
>>>>>> rebuttal.
>>>>>>
>>>>>> No halt decider ever directly executes its input yet must
>>>>>> correctly predict the behavior of this directly executed or
>>>>>> correctly simulated input.
>>>>>>
>>>>>
>>>>> Right, THE behavior of direct execution or correct simulation, not
>>>>> by the decider, but just done.
>>>>>
>>>>> If you want to add the words "by the decider", you need a source
>>>>> for that, which you have failed to do.
>>>>
>>>> First you must agree that every Hx returning 0 does correctly report
>>>> the halt status of the behavior of what its direct execution of
>>>> Px(Px) would be if it directly executed this input.
>>>>
>>>
>>> No. because no Hx that does a direct execution even gives an answer,
>>> so your statement is ILLOGICAL.
>> Halt deciders are not supposed to do a direct execution and you know
>> this so what the Hell are you trying to pull here?
>>
>
> Right, the aren't supposed to so why do you think they need to act like
> they did?
Halt deciders must correctly predict what the behavior of their directly
executed or correctly simulated input would be Hx(Px,Px)==0 does that.

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7mmh$kb3u$7@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 13:06:09 -0500
Organization: A noiseless patient Spider
Lines: 84
Message-ID: <tg7mmh$kb3u$7@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <KHrVK.119006$479c.105120@fx48.iad>
<tg5hij$133t$1@gioia.aioe.org> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
<tg7lt7$kb3u$5@dont-email.me> <GZIVK.53332$SMP5.52260@fx05.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 18:06:09 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="666750"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18uKhq4OjUh2G3UwplYPK/r"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:EnH+ZK+efjHm5GBamY0dCtwy3E0=
Content-Language: en-US
In-Reply-To: <GZIVK.53332$SMP5.52260@fx05.iad>
 by: olcott - Sun, 18 Sep 2022 18:06 UTC

On 9/18/2022 12:56 PM, Richard Damon wrote:
> On 9/18/22 1:52 PM, olcott wrote:
>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>> On 9/18/22 1:44 PM, olcott wrote:
>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>
>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>> {
>>>>>>>>>>>>    return 0;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't halt.
>>>>>>>>>>>
>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER
>>>>>>>>>> report
>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx
>>>>>>>>>> will be
>>>>>>>>>>  > non-halting.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>> this input would never halt is a wild guess.
>>>>>>>
>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>> asked of it.
>>>>>>>
>>>>>> Why do I have to tell you the same thing 500 times and you still
>>>>>> don't get it?  My theory is that you are a liar only interested in
>>>>>> rebuttal.
>>>>>>
>>>>>> No halt decider ever directly executes its input yet must
>>>>>> correctly predict the behavior of this directly executed or
>>>>>> correctly simulated input.
>>>>>>
>>>>>
>>>>> Right, THE behavior of direct execution or correct simulation, not
>>>>> by the decider, but just done.
>>>>>
>>>>> If you want to add the words "by the decider", you need a source
>>>>> for that, which you have failed to do.
>>>>
>>>> First you must agree that every Hx returning 0 does correctly report
>>>> the halt status of the behavior of what its direct execution of
>>>> Px(Px) would be if it directly executed this input.
>>>>
>>>
>>> No. because no Hx that does a direct execution even gives an answer,
>>> so your statement is ILLOGICAL.
>> Halt deciders are not supposed to do a direct execution and you know
>> this so what the Hell are you trying to pull here?
>>
>
> Right, the aren't supposed to so why do you think they need to act like
> they did?
Halt deciders must correctly predict what the behavior of their directly
executed or correctly simulated input would be:

On 9/17/2022 9:38 PM, Richard Damon wrote:
> If Hx DOES directly execute its input, then it
> will NEVER report non-halting, and yes, then the
> input Px built from THAT Hx will be non-halting.

So you have already agreed that Hx(Px,Px)==0 is correct.

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<joJVK.176735$3AK7.37281@fx35.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5hij$133t$1@gioia.aioe.org>
<RXrVK.177198$9Yp5.146998@fx12.iad> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
<XHIVK.295044$wLZ8.42432@fx18.iad> <tg7le7$kb3u$4@dont-email.me>
<PSIVK.36387$ocy7.6704@fx38.iad> <tg7lt7$kb3u$5@dont-email.me>
<GZIVK.53332$SMP5.52260@fx05.iad> <tg7mmh$kb3u$7@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7mmh$kb3u$7@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 99
Message-ID: <joJVK.176735$3AK7.37281@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 14:25:19 -0400
X-Received-Bytes: 5589
 by: Richard Damon - Sun, 18 Sep 2022 18:25 UTC

On 9/18/22 2:06 PM, olcott wrote:
> On 9/18/2022 12:56 PM, Richard Damon wrote:
>> On 9/18/22 1:52 PM, olcott wrote:
>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>
>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't
>>>>>>>>>>>> halt.
>>>>>>>>>>>>
>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER
>>>>>>>>>>> report
>>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT Hx
>>>>>>>>>>> will be
>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>>> this input would never halt is a wild guess.
>>>>>>>>
>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>> asked of it.
>>>>>>>>
>>>>>>> Why do I have to tell you the same thing 500 times and you still
>>>>>>> don't get it?  My theory is that you are a liar only interested
>>>>>>> in rebuttal.
>>>>>>>
>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>> correctly simulated input.
>>>>>>>
>>>>>>
>>>>>> Right, THE behavior of direct execution or correct simulation, not
>>>>>> by the decider, but just done.
>>>>>>
>>>>>> If you want to add the words "by the decider", you need a source
>>>>>> for that, which you have failed to do.
>>>>>
>>>>> First you must agree that every Hx returning 0 does correctly
>>>>> report the halt status of the behavior of what its direct execution
>>>>> of Px(Px) would be if it directly executed this input.
>>>>>
>>>>
>>>> No. because no Hx that does a direct execution even gives an answer,
>>>> so your statement is ILLOGICAL.
>>> Halt deciders are not supposed to do a direct execution and you know
>>> this so what the Hell are you trying to pull here?
>>>
>>
>> Right, the aren't supposed to so why do you think they need to act
>> like they did?
> Halt deciders must correctly predict what the behavior of their directly
> executed or correctly simulated input would be:
>
> On 9/17/2022 9:38 PM, Richard Damon wrote:
> > If Hx DOES directly execute its input, then it
> > will NEVER report non-halting, and yes, then the
> > input Px built from THAT Hx will be non-halting.
>
> So you have already agreed that Hx(Px,Px)==0 is correct.
>

Where?

If Hx is DEFINED to directly execute its input, it can't return 0 from
Hx(Px, Px), so while a return of 0 WOULD have been correct, it can't happen.

Any Hx that returns 0 from Hx(Px,Px) is incorrect, because the direct
execution of its input (that it doesn't do) is shown to return in finite
time.

You are just showing you don't understand what the words mean.

I think you have confused yourself with your own gaslighting terminology.

In other words, you have made yourself stupider by listening to your own
lies.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7oh7$le5v$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 13:37:27 -0500
Organization: A noiseless patient Spider
Lines: 97
Message-ID: <tg7oh7$le5v$1@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
<tg7lt7$kb3u$5@dont-email.me> <GZIVK.53332$SMP5.52260@fx05.iad>
<tg7mmh$kb3u$7@dont-email.me> <joJVK.176735$3AK7.37281@fx35.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 18:37:27 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="702655"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19zTN1PaBKFQ9VRq/KMYVRW"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:KSr0pxqLrGgtgi8f1vf0Cmy3lLA=
In-Reply-To: <joJVK.176735$3AK7.37281@fx35.iad>
Content-Language: en-US
 by: olcott - Sun, 18 Sep 2022 18:37 UTC

On 9/18/2022 1:25 PM, Richard Damon wrote:
> On 9/18/22 2:06 PM, olcott wrote:
>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>> On 9/18/22 1:52 PM, olcott wrote:
>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't
>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>
>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER
>>>>>>>>>>>> report
>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT
>>>>>>>>>>>> Hx will be
>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>>>> this input would never halt is a wild guess.
>>>>>>>>>
>>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>>> asked of it.
>>>>>>>>>
>>>>>>>> Why do I have to tell you the same thing 500 times and you still
>>>>>>>> don't get it?  My theory is that you are a liar only interested
>>>>>>>> in rebuttal.
>>>>>>>>
>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>> correctly simulated input.
>>>>>>>>
>>>>>>>
>>>>>>> Right, THE behavior of direct execution or correct simulation,
>>>>>>> not by the decider, but just done.
>>>>>>>
>>>>>>> If you want to add the words "by the decider", you need a source
>>>>>>> for that, which you have failed to do.
>>>>>>
>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>> report the halt status of the behavior of what its direct
>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>
>>>>>
>>>>> No. because no Hx that does a direct execution even gives an
>>>>> answer, so your statement is ILLOGICAL.
>>>> Halt deciders are not supposed to do a direct execution and you know
>>>> this so what the Hell are you trying to pull here?
>>>>
>>>
>>> Right, the aren't supposed to so why do you think they need to act
>>> like they did?
>> Halt deciders must correctly predict what the behavior of their
>> directly executed or correctly simulated input would be:
>>
>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>  > If Hx DOES directly execute its input, then it
>>  > will NEVER report non-halting, and yes, then the
>>  > input Px built from THAT Hx will be non-halting.
>>
>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>
>
> Where?
>

On 9/17/2022 9:38 PM, Richard Damon wrote:
> If Hx DOES directly execute its input, then it
> will NEVER report non-halting, and yes, then the
> input Px built from THAT Hx will be non-halting.

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7p71$le5v$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 13:49:05 -0500
Organization: A noiseless patient Spider
Lines: 100
Message-ID: <tg7p71$le5v$2@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <RXrVK.177198$9Yp5.146998@fx12.iad>
<tg5io0$8g1j$5@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
<tg7lt7$kb3u$5@dont-email.me> <GZIVK.53332$SMP5.52260@fx05.iad>
<tg7mmh$kb3u$7@dont-email.me> <joJVK.176735$3AK7.37281@fx35.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 18:49:05 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="702655"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/YWxUsLRouYDqUBZK4rZs0"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:ZEnOUz6ClxLCBoItc5Rnt8tq9ic=
Content-Language: en-US
In-Reply-To: <joJVK.176735$3AK7.37281@fx35.iad>
 by: olcott - Sun, 18 Sep 2022 18:49 UTC

On 9/18/2022 1:25 PM, Richard Damon wrote:
> On 9/18/22 2:06 PM, olcott wrote:
>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>> On 9/18/22 1:52 PM, olcott wrote:
>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't
>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>
>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will NEVER
>>>>>>>>>>>> report
>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT
>>>>>>>>>>>> Hx will be
>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>>>> this input would never halt is a wild guess.
>>>>>>>>>
>>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>>> asked of it.
>>>>>>>>>
>>>>>>>> Why do I have to tell you the same thing 500 times and you still
>>>>>>>> don't get it?  My theory is that you are a liar only interested
>>>>>>>> in rebuttal.
>>>>>>>>
>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>> correctly simulated input.
>>>>>>>>
>>>>>>>
>>>>>>> Right, THE behavior of direct execution or correct simulation,
>>>>>>> not by the decider, but just done.
>>>>>>>
>>>>>>> If you want to add the words "by the decider", you need a source
>>>>>>> for that, which you have failed to do.
>>>>>>
>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>> report the halt status of the behavior of what its direct
>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>
>>>>>
>>>>> No. because no Hx that does a direct execution even gives an
>>>>> answer, so your statement is ILLOGICAL.
>>>> Halt deciders are not supposed to do a direct execution and you know
>>>> this so what the Hell are you trying to pull here?
>>>>
>>>
>>> Right, the aren't supposed to so why do you think they need to act
>>> like they did?
>> Halt deciders must correctly predict what the behavior of their
>> directly executed or correctly simulated input would be:
>>
>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>  > If Hx DOES directly execute its input, then it
>>  > will NEVER report non-halting, and yes, then the
>>  > input Px built from THAT Hx will be non-halting.
>>
>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>
>
> Where?

On 9/17/2022 9:38 PM, Richard Damon wrote:
> If Hx DOES directly execute its input, then it
> will NEVER report non-halting, and yes, then the
> input Px built from THAT Hx will be non-halting.

The infinite set of every Hx element of the Hx/Px pairs that directly
executes its input never halts therefore when Hx(Px,Px)==0 means that
its own direct execution of its input would never halt it is necessarily
correct.

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<4LJVK.119097$479c.105679@fx48.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
<XHIVK.295044$wLZ8.42432@fx18.iad> <tg7le7$kb3u$4@dont-email.me>
<PSIVK.36387$ocy7.6704@fx38.iad> <tg7lt7$kb3u$5@dont-email.me>
<GZIVK.53332$SMP5.52260@fx05.iad> <tg7mmh$kb3u$7@dont-email.me>
<joJVK.176735$3AK7.37281@fx35.iad> <tg7oh7$le5v$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7oh7$le5v$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 109
Message-ID: <4LJVK.119097$479c.105679@fx48.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 14:49:35 -0400
X-Received-Bytes: 6100
 by: Richard Damon - Sun, 18 Sep 2022 18:49 UTC

On 9/18/22 2:37 PM, olcott wrote:
> On 9/18/2022 1:25 PM, Richard Damon wrote:
>> On 9/18/22 2:06 PM, olcott wrote:
>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't
>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will
>>>>>>>>>>>>> NEVER report
>>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT
>>>>>>>>>>>>> Hx will be
>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>>>>> this input would never halt is a wild guess.
>>>>>>>>>>
>>>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>>>> asked of it.
>>>>>>>>>>
>>>>>>>>> Why do I have to tell you the same thing 500 times and you
>>>>>>>>> still don't get it?  My theory is that you are a liar only
>>>>>>>>> interested in rebuttal.
>>>>>>>>>
>>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>>> correctly simulated input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, THE behavior of direct execution or correct simulation,
>>>>>>>> not by the decider, but just done.
>>>>>>>>
>>>>>>>> If you want to add the words "by the decider", you need a source
>>>>>>>> for that, which you have failed to do.
>>>>>>>
>>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>>> report the halt status of the behavior of what its direct
>>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>>
>>>>>>
>>>>>> No. because no Hx that does a direct execution even gives an
>>>>>> answer, so your statement is ILLOGICAL.
>>>>> Halt deciders are not supposed to do a direct execution and you
>>>>> know this so what the Hell are you trying to pull here?
>>>>>
>>>>
>>>> Right, the aren't supposed to so why do you think they need to act
>>>> like they did?
>>> Halt deciders must correctly predict what the behavior of their
>>> directly executed or correctly simulated input would be:
>>>
>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>  > If Hx DOES directly execute its input, then it
>>>  > will NEVER report non-halting, and yes, then the
>>>  > input Px built from THAT Hx will be non-halting.
>>>
>>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>>
>>
>> Where?
>>
>
> On 9/17/2022 9:38 PM, Richard Damon wrote:
> > If Hx DOES directly execute its input, then it
> > will NEVER report non-halting, and yes, then the
> > input Px built from THAT Hx will be non-halting.
>
>

That doesn't say what you said I said.

You are just proving you are a liar.

Yes, IF Hx COULD report Hx(Px,Px) as 0, it would have been correct, but
it can't.

I didn't say Hx IS correct, because Hx can't do what you says it does.
Thus a Hx that returns 0 is NOT correct, because it doesn't meet the
requirements for that to be the correct answer, namely that Hx never
gives an answer.

Yes, you would be a Billionaire if you had a Billion dollars, but you
don't so don't write a check eck based on the assumption that it would
be good if you were one.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<wSJVK.301707$SAT4.179439@fx13.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.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.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5io0$8g1j$5@dont-email.me>
<qCsVK.294880$wLZ8.17299@fx18.iad> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
<XHIVK.295044$wLZ8.42432@fx18.iad> <tg7le7$kb3u$4@dont-email.me>
<PSIVK.36387$ocy7.6704@fx38.iad> <tg7lt7$kb3u$5@dont-email.me>
<GZIVK.53332$SMP5.52260@fx05.iad> <tg7mmh$kb3u$7@dont-email.me>
<joJVK.176735$3AK7.37281@fx35.iad> <tg7p71$le5v$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7p71$le5v$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 120
Message-ID: <wSJVK.301707$SAT4.179439@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 14:57:31 -0400
X-Received-Bytes: 6663
 by: Richard Damon - Sun, 18 Sep 2022 18:57 UTC

On 9/18/22 2:49 PM, olcott wrote:
> On 9/18/2022 1:25 PM, Richard Damon wrote:
>> On 9/18/22 2:06 PM, olcott wrote:
>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input wouldn't
>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will
>>>>>>>>>>>>> NEVER report
>>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT
>>>>>>>>>>>>> Hx will be
>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>>> Its basis for correctly deciding that the direct execution of
>>>>>>>>>>> this input would never halt is a wild guess.
>>>>>>>>>>
>>>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>>>> asked of it.
>>>>>>>>>>
>>>>>>>>> Why do I have to tell you the same thing 500 times and you
>>>>>>>>> still don't get it?  My theory is that you are a liar only
>>>>>>>>> interested in rebuttal.
>>>>>>>>>
>>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>>> correctly simulated input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, THE behavior of direct execution or correct simulation,
>>>>>>>> not by the decider, but just done.
>>>>>>>>
>>>>>>>> If you want to add the words "by the decider", you need a source
>>>>>>>> for that, which you have failed to do.
>>>>>>>
>>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>>> report the halt status of the behavior of what its direct
>>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>>
>>>>>>
>>>>>> No. because no Hx that does a direct execution even gives an
>>>>>> answer, so your statement is ILLOGICAL.
>>>>> Halt deciders are not supposed to do a direct execution and you
>>>>> know this so what the Hell are you trying to pull here?
>>>>>
>>>>
>>>> Right, the aren't supposed to so why do you think they need to act
>>>> like they did?
>>> Halt deciders must correctly predict what the behavior of their
>>> directly executed or correctly simulated input would be:
>>>
>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>  > If Hx DOES directly execute its input, then it
>>>  > will NEVER report non-halting, and yes, then the
>>>  > input Px built from THAT Hx will be non-halting.
>>>
>>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>>
>>
>> Where?
>
> On 9/17/2022 9:38 PM, Richard Damon wrote:
> > If Hx DOES directly execute its input, then it
> > will NEVER report non-halting, and yes, then the
> > input Px built from THAT Hx will be non-halting.
>
> The infinite set of every Hx element of the Hx/Px pairs that directly
> executes its input never halts therefore when Hx(Px,Px)==0 means that
> its own direct execution of its input would never halt it is necessarily
> correct.
>
Nope. More proof of your stupidity.

NO Hx(Px,Px) that returns 0 has a Px that is based on an Hx that does a
direct execution, by the definition of Px.

EVERY Hx in the set that does a direct exectution is processing a Px
that is that calls an Hx that does a direct exectution.

Thus these SETS are disjoint and tell nothing of each other.

You are just admitting that you are LYING that Hx processes its ACTUAL
input, as it thinks its Px is something different than the Px that it
has actually been given.

You are just proving your total ignorance of the subject. Hx needs to
answer about its ACTUAL input, not some input that is vaguely in the
same class as its own,

BY YOUR LOGIC, ANY decider can give ANY answer and be correct, you just
need to build an apprpriate "set" to show what you want.

YOU HAVE BURIED YOUR REPUTATION under your pile of LIES.

YOU HAVE FAILED.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7qj7$le5v$3@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 14:12:39 -0500
Organization: A noiseless patient Spider
Lines: 133
Message-ID: <tg7qj7$le5v$3@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <qCsVK.294880$wLZ8.17299@fx18.iad>
<tg5l69$92pb$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
<tg7lt7$kb3u$5@dont-email.me> <GZIVK.53332$SMP5.52260@fx05.iad>
<tg7mmh$kb3u$7@dont-email.me> <joJVK.176735$3AK7.37281@fx35.iad>
<tg7p71$le5v$2@dont-email.me> <wSJVK.301707$SAT4.179439@fx13.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 19:12:39 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="702655"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Aq6GBy9enotk9hFwG6mD8"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:L+Q+s3Ni/poSPBL5E96A7TE2tBs=
In-Reply-To: <wSJVK.301707$SAT4.179439@fx13.iad>
Content-Language: en-US
 by: olcott - Sun, 18 Sep 2022 19:12 UTC

On 9/18/2022 1:57 PM, Richard Damon wrote:
> On 9/18/22 2:49 PM, olcott wrote:
>> On 9/18/2022 1:25 PM, Richard Damon wrote:
>>> On 9/18/22 2:06 PM, olcott wrote:
>>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input
>>>>>>>>>>>>>>> wouldn't halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will
>>>>>>>>>>>>>> NEVER report
>>>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from THAT
>>>>>>>>>>>>>> Hx will be
>>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>>>> Its basis for correctly deciding that the direct execution
>>>>>>>>>>>> of this input would never halt is a wild guess.
>>>>>>>>>>>
>>>>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>>>>> asked of it.
>>>>>>>>>>>
>>>>>>>>>> Why do I have to tell you the same thing 500 times and you
>>>>>>>>>> still don't get it?  My theory is that you are a liar only
>>>>>>>>>> interested in rebuttal.
>>>>>>>>>>
>>>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>>>> correctly simulated input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, THE behavior of direct execution or correct simulation,
>>>>>>>>> not by the decider, but just done.
>>>>>>>>>
>>>>>>>>> If you want to add the words "by the decider", you need a
>>>>>>>>> source for that, which you have failed to do.
>>>>>>>>
>>>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>>>> report the halt status of the behavior of what its direct
>>>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>>>
>>>>>>>
>>>>>>> No. because no Hx that does a direct execution even gives an
>>>>>>> answer, so your statement is ILLOGICAL.
>>>>>> Halt deciders are not supposed to do a direct execution and you
>>>>>> know this so what the Hell are you trying to pull here?
>>>>>>
>>>>>
>>>>> Right, the aren't supposed to so why do you think they need to act
>>>>> like they did?
>>>> Halt deciders must correctly predict what the behavior of their
>>>> directly executed or correctly simulated input would be:
>>>>
>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>  > If Hx DOES directly execute its input, then it
>>>>  > will NEVER report non-halting, and yes, then the
>>>>  > input Px built from THAT Hx will be non-halting.
>>>>
>>>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>>>
>>>
>>> Where?
>>
>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>  > If Hx DOES directly execute its input, then it
>>  > will NEVER report non-halting, and yes, then the
>>  > input Px built from THAT Hx will be non-halting.
>>
>> The infinite set of every Hx element of the Hx/Px pairs that directly
>> executes its input never halts therefore when Hx(Px,Px)==0 means that
>> its own direct execution of its input would never halt it is
>> necessarily correct.
>>
> Nope. More proof of your stupidity.
>
> NO Hx(Px,Px) that returns 0 has a Px that is based on an Hx that does a
> direct execution, by the definition of Px.
Since you already know that no halt decider ever directly executes its
input and instead only predicts what the behavior of this directly
executed input would be *you have proven to be a liar*

(1) Every element of the infinite set of Hx/Px pairs where Hx directly
executes its input never halts

(2) Every Hx(Px,Px) that returns 0 correctly predicts what the behavior
of its input would be if it directly executed this input because the
adaptation of this Hx/Px pair is already a member of (1).

int Hx(ptr x, ptr y)
{ return 0;
}

adapted so it directly executes its input becomes

int Hx(ptr x, ptr y)
{ x(y);
return 0;
}

which is already an element of (1).

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

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<%cKVK.36389$ocy7.5762@fx38.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Content-Language: en-US
Newsgroups: comp.theory
References: <tg27ie$3s073$1@dont-email.me> <tg5l69$92pb$1@dont-email.me>
<9WsVK.294881$wLZ8.234803@fx18.iad> <tg5m5t$95bg$1@dont-email.me>
<sctVK.113524$6gz7.7727@fx37.iad> <tg5nhp$95bg$2@dont-email.me>
<GBtVK.442147$Ny99.216665@fx16.iad> <tg5qnu$9g6m$1@dont-email.me>
<lguVK.42529$OR4c.10053@fx46.iad> <tg5sr8$9g6m$2@dont-email.me>
<IwvVK.92356$chF5.76629@fx08.iad> <tg615k$cq7b$1@dont-email.me>
<l7wVK.206653$PRW4.115367@fx11.iad> <tg65qv$d3nv$1@dont-email.me>
<fgDVK.206672$PRW4.133142@fx11.iad> <tg7ct1$iutf$1@dont-email.me>
<BHHVK.547346$BKL8.25399@fx15.iad> <tg7itp$kb3u$1@dont-email.me>
<puIVK.295043$wLZ8.84102@fx18.iad> <tg7kfe$kb3u$3@dont-email.me>
<XHIVK.295044$wLZ8.42432@fx18.iad> <tg7le7$kb3u$4@dont-email.me>
<PSIVK.36387$ocy7.6704@fx38.iad> <tg7lt7$kb3u$5@dont-email.me>
<GZIVK.53332$SMP5.52260@fx05.iad> <tg7mmh$kb3u$7@dont-email.me>
<joJVK.176735$3AK7.37281@fx35.iad> <tg7p71$le5v$2@dont-email.me>
<wSJVK.301707$SAT4.179439@fx13.iad> <tg7qj7$le5v$3@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tg7qj7$le5v$3@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 170
Message-ID: <%cKVK.36389$ocy7.5762@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 18 Sep 2022 15:21:31 -0400
X-Received-Bytes: 8021
 by: Richard Damon - Sun, 18 Sep 2022 19:21 UTC

On 9/18/22 3:12 PM, olcott wrote:
> On 9/18/2022 1:57 PM, Richard Damon wrote:
>> On 9/18/22 2:49 PM, olcott wrote:
>>> On 9/18/2022 1:25 PM, Richard Damon wrote:
>>>> On 9/18/22 2:06 PM, olcott wrote:
>>>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input
>>>>>>>>>>>>>>>> wouldn't halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will
>>>>>>>>>>>>>>> NEVER report
>>>>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from
>>>>>>>>>>>>>>> THAT Hx will be
>>>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>>>>> Its basis for correctly deciding that the direct execution
>>>>>>>>>>>>> of this input would never halt is a wild guess.
>>>>>>>>>>>>
>>>>>>>>>>>> So, it guesses wrong about the actual question that is being
>>>>>>>>>>>> asked of it.
>>>>>>>>>>>>
>>>>>>>>>>> Why do I have to tell you the same thing 500 times and you
>>>>>>>>>>> still don't get it?  My theory is that you are a liar only
>>>>>>>>>>> interested in rebuttal.
>>>>>>>>>>>
>>>>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>>>>> correctly simulated input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, THE behavior of direct execution or correct simulation,
>>>>>>>>>> not by the decider, but just done.
>>>>>>>>>>
>>>>>>>>>> If you want to add the words "by the decider", you need a
>>>>>>>>>> source for that, which you have failed to do.
>>>>>>>>>
>>>>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>>>>> report the halt status of the behavior of what its direct
>>>>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No. because no Hx that does a direct execution even gives an
>>>>>>>> answer, so your statement is ILLOGICAL.
>>>>>>> Halt deciders are not supposed to do a direct execution and you
>>>>>>> know this so what the Hell are you trying to pull here?
>>>>>>>
>>>>>>
>>>>>> Right, the aren't supposed to so why do you think they need to act
>>>>>> like they did?
>>>>> Halt deciders must correctly predict what the behavior of their
>>>>> directly executed or correctly simulated input would be:
>>>>>
>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>  > If Hx DOES directly execute its input, then it
>>>>>  > will NEVER report non-halting, and yes, then the
>>>>>  > input Px built from THAT Hx will be non-halting.
>>>>>
>>>>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>>>>
>>>>
>>>> Where?
>>>
>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>  > If Hx DOES directly execute its input, then it
>>>  > will NEVER report non-halting, and yes, then the
>>>  > input Px built from THAT Hx will be non-halting.
>>>
>>> The infinite set of every Hx element of the Hx/Px pairs that directly
>>> executes its input never halts therefore when Hx(Px,Px)==0 means that
>>> its own direct execution of its input would never halt it is
>>> necessarily correct.
>>>
>> Nope. More proof of your stupidity.
>>
>> NO Hx(Px,Px) that returns 0 has a Px that is based on an Hx that does
>> a direct execution, by the definition of Px.
> Since you already know that no halt decider ever directly executes its
> input and instead only predicts what the behavior of this directly
> executed input would be *you have proven to be a liar*
>
> (1) Every element of the infinite set of Hx/Px pairs where Hx directly
> executes its input never halts

Which is a subset of ONLY those Px built on an Hx that NEVER returns.

>
> (2) Every Hx(Px,Px) that returns 0 correctly predicts what the behavior
> of its input would be if it directly executed this input because the
> adaptation of this Hx/Px pair is already a member of (1).
>

But its input is NOT part of the subset from above, so the conclusion is
INVALID.

> int Hx(ptr x, ptr y)
> {
>   return 0;
> }
>
> adapted so it directly executes its input becomes

Which is an INVALID change to the input. PERIOD.

This means your Hx is now handling a DIFFERENT input, and thus your
logic is INVALID.

>
> int Hx(ptr x, ptr y)
> {
>   x(y);
>   return 0;
> }
>
> which is already an element of (1).
>
>

You COULD do:

define Hx to be the decider you claim gets the right answer.

void Px(Ptr x) {
int res = Hx(x,x)
while(res) continue;
}

int Hy(ptr x, ptr y) {
x(y);
return 1; // Since if it returns, it must have need Halting.
}

NOW, Hy(P,P) returning 1 shows that Hx(P,P) returning 0 was wrong.

You are just PROVING your utter stupidity by making INVALID claims that
violate the basic laws of logic.

YOU HAVE KILLED AND BURIED your reputation.

You will FOREVER be known as the ignorant pathological lying idiot who
doesn't understand the first thing about what he was talking about.

You might have had some interesting ideas at one time, but you are
filled them with poision so they don't mean anything.

Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem proofs) V2

<tg7rle$le5v$4@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Hx(Px,Px)==0 is proven to be correct (refuting halting problem
proofs) V2
Date: Sun, 18 Sep 2022 14:30:55 -0500
Organization: A noiseless patient Spider
Lines: 151
Message-ID: <tg7rle$le5v$4@dont-email.me>
References: <tg27ie$3s073$1@dont-email.me> <9WsVK.294881$wLZ8.234803@fx18.iad>
<tg5m5t$95bg$1@dont-email.me> <sctVK.113524$6gz7.7727@fx37.iad>
<tg5nhp$95bg$2@dont-email.me> <GBtVK.442147$Ny99.216665@fx16.iad>
<tg5qnu$9g6m$1@dont-email.me> <lguVK.42529$OR4c.10053@fx46.iad>
<tg5sr8$9g6m$2@dont-email.me> <IwvVK.92356$chF5.76629@fx08.iad>
<tg615k$cq7b$1@dont-email.me> <l7wVK.206653$PRW4.115367@fx11.iad>
<tg65qv$d3nv$1@dont-email.me> <fgDVK.206672$PRW4.133142@fx11.iad>
<tg7ct1$iutf$1@dont-email.me> <BHHVK.547346$BKL8.25399@fx15.iad>
<tg7itp$kb3u$1@dont-email.me> <puIVK.295043$wLZ8.84102@fx18.iad>
<tg7kfe$kb3u$3@dont-email.me> <XHIVK.295044$wLZ8.42432@fx18.iad>
<tg7le7$kb3u$4@dont-email.me> <PSIVK.36387$ocy7.6704@fx38.iad>
<tg7lt7$kb3u$5@dont-email.me> <GZIVK.53332$SMP5.52260@fx05.iad>
<tg7mmh$kb3u$7@dont-email.me> <joJVK.176735$3AK7.37281@fx35.iad>
<tg7p71$le5v$2@dont-email.me> <wSJVK.301707$SAT4.179439@fx13.iad>
<tg7qj7$le5v$3@dont-email.me> <%cKVK.36389$ocy7.5762@fx38.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 Sep 2022 19:30:54 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="08c1f3b082a6d437c9a5b1291e684f24";
logging-data="702655"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+Yrxepwo5cE79v8YX/t7j5"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.2.2
Cancel-Lock: sha1:sUQgrS3lRYQrAC0WdARLdFIqI7c=
Content-Language: en-US
In-Reply-To: <%cKVK.36389$ocy7.5762@fx38.iad>
 by: olcott - Sun, 18 Sep 2022 19:30 UTC

On 9/18/2022 2:21 PM, Richard Damon wrote:
> On 9/18/22 3:12 PM, olcott wrote:
>> On 9/18/2022 1:57 PM, Richard Damon wrote:
>>> On 9/18/22 2:49 PM, olcott wrote:
>>>> On 9/18/2022 1:25 PM, Richard Damon wrote:
>>>>> On 9/18/22 2:06 PM, olcott wrote:
>>>>>> On 9/18/2022 12:56 PM, Richard Damon wrote:
>>>>>>> On 9/18/22 1:52 PM, olcott wrote:
>>>>>>>> On 9/18/2022 12:49 PM, Richard Damon wrote:
>>>>>>>>> On 9/18/22 1:44 PM, olcott wrote:
>>>>>>>>>> On 9/18/2022 12:37 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/18/22 1:28 PM, olcott wrote:
>>>>>>>>>>>> On 9/18/2022 12:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/18/22 1:01 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/18/2022 11:29 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/18/22 11:18 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/18/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/18/22 12:12 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> This instance of Hx(Px,Px) correctly reports its direct
>>>>>>>>>>>>>>>>>> execution of its input never halts:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it doesn't. It is only correct *IF* its input
>>>>>>>>>>>>>>>>> wouldn't halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>  > If Hx DOES directly execute its input, then it will
>>>>>>>>>>>>>>>> NEVER report
>>>>>>>>>>>>>>>>  > non-halting, and yes, then the input Px built from
>>>>>>>>>>>>>>>> THAT Hx will be
>>>>>>>>>>>>>>>>  > non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And since Hx doesn't directly execute its input,
>>>>>>>>>>>>>> Its basis for correctly deciding that the direct execution
>>>>>>>>>>>>>> of this input would never halt is a wild guess.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, it guesses wrong about the actual question that is
>>>>>>>>>>>>> being asked of it.
>>>>>>>>>>>>>
>>>>>>>>>>>> Why do I have to tell you the same thing 500 times and you
>>>>>>>>>>>> still don't get it?  My theory is that you are a liar only
>>>>>>>>>>>> interested in rebuttal.
>>>>>>>>>>>>
>>>>>>>>>>>> No halt decider ever directly executes its input yet must
>>>>>>>>>>>> correctly predict the behavior of this directly executed or
>>>>>>>>>>>> correctly simulated input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, THE behavior of direct execution or correct
>>>>>>>>>>> simulation, not by the decider, but just done.
>>>>>>>>>>>
>>>>>>>>>>> If you want to add the words "by the decider", you need a
>>>>>>>>>>> source for that, which you have failed to do.
>>>>>>>>>>
>>>>>>>>>> First you must agree that every Hx returning 0 does correctly
>>>>>>>>>> report the halt status of the behavior of what its direct
>>>>>>>>>> execution of Px(Px) would be if it directly executed this input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No. because no Hx that does a direct execution even gives an
>>>>>>>>> answer, so your statement is ILLOGICAL.
>>>>>>>> Halt deciders are not supposed to do a direct execution and you
>>>>>>>> know this so what the Hell are you trying to pull here?
>>>>>>>>
>>>>>>>
>>>>>>> Right, the aren't supposed to so why do you think they need to
>>>>>>> act like they did?
>>>>>> Halt deciders must correctly predict what the behavior of their
>>>>>> directly executed or correctly simulated input would be:
>>>>>>
>>>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>>>  > If Hx DOES directly execute its input, then it
>>>>>>  > will NEVER report non-halting, and yes, then the
>>>>>>  > input Px built from THAT Hx will be non-halting.
>>>>>>
>>>>>> So you have already agreed that Hx(Px,Px)==0 is correct.
>>>>>>
>>>>>
>>>>> Where?
>>>>
>>>> On 9/17/2022 9:38 PM, Richard Damon wrote:
>>>>  > If Hx DOES directly execute its input, then it
>>>>  > will NEVER report non-halting, and yes, then the
>>>>  > input Px built from THAT Hx will be non-halting.
>>>>
>>>> The infinite set of every Hx element of the Hx/Px pairs that
>>>> directly executes its input never halts therefore when Hx(Px,Px)==0
>>>> means that its own direct execution of its input would never halt it
>>>> is necessarily correct.
>>>>
>>> Nope. More proof of your stupidity.
>>>
>>> NO Hx(Px,Px) that returns 0 has a Px that is based on an Hx that does
>>> a direct execution, by the definition of Px.
>> Since you already know that no halt decider ever directly executes its
>> input and instead only predicts what the behavior of this directly
>> executed input would be *you have proven to be a liar*
>>
>> (1) Every element of the infinite set of Hx/Px pairs where Hx directly
>> executes its input never halts
>
> Which is a subset of ONLY those Px built on an Hx that NEVER returns.
>
>>
>> (2) Every Hx(Px,Px) that returns 0 correctly predicts what the
>> behavior of its input would be if it directly executed this input
>> because the adaptation of this Hx/Px pair is already a member of (1).
>>
>
> But its input is NOT part of the subset from above, so the conclusion is
> INVALID.
>
>> int Hx(ptr x, ptr y)
>> {
>>    return 0;
>> }
>>
>> adapted so it directly executes its input becomes
>
> Which is an INVALID change to the input. PERIOD.
>
> This means your Hx is now handling a DIFFERENT input, and thus your
> logic is INVALID.
>
>>
>> int Hx(ptr x, ptr y)
>> {
>>    x(y);
>>    return 0;
>> }
>>
>> which is already an element of (1).
>>
>>
Therefore Hx(Px,Px)==0 is necessarily correct about what the behavior of
its the input would be if it directly executed this input.

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

Pages:12345678
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor