Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

I am NOT a kludge! I am a computer! -- tts


devel / comp.theory / Re: Concise refutation of halting problem proofs V52 [ Honest Dialogue Begins ]

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

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

<3dJHJ.17533$f04.698@fx23.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx23.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
<87mHJ.22633$dG7.7407@fx47.iad>
<GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
<wSmHJ.53088$Y01.31344@fx45.iad>
<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
<aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 481
Message-ID: <3dJHJ.17533$f04.698@fx23.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: Mon, 24 Jan 2022 21:26:07 -0500
X-Received-Bytes: 26612
 by: Richard Damon - Tue, 25 Jan 2022 02:26 UTC

On 1/24/22 9:11 PM, olcott wrote:
> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>
>> On 1/24/22 8:32 PM, olcott wrote:
>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true for infinite loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion, infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation and all other non
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulated input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input in any finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps it is always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for the simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider to abort its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transition to its reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you PROVE that statement, or is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this just one of your false 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that x86 language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that its easy to match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec            mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe            jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do one case does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove that the same method works
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on all, particularly harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you serving Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does NOT show up in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE lies by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the input includes a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its halt status decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pure simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ -> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and for H^ <H^> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must be true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because we know that the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an Turing Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't prove what you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out of your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that IF the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider does abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input based on some condition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is no longer a source of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for the halting status of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the input stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, which H are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, then H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of the input WILL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at H^.Qn, so H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT ENOUGH TO GET
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS. IT CAN BE VERIFIED AS COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON THE BASIS OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this is complete prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state (when simulated by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H) then, YES, H can go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due to 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^, ANY pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H sees in its simulation of <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it transitions to H.Qn, will BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, become a halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated INPUT that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state anyway. YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I said there is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H use to detect that it won't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any pattern that H uses to decide
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go to H.Qn will be WRONG for H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^ also goes to H^.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have only proved that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the case where H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a box of rocks
>>>>>>>>>>>>>>>>>>>>>>>>>>> (or perhaps you are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I never mentioned the
>>>>>>>>>>>>>>>>>>>>>>>>>>> word: "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much dumber than a
>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well (you nearly
>>>>>>>>>>>>>>>>>>>>>>>>>>> passed the Turing test) it took me this long
>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that you are not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is the same as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H never reaches a final state
>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H doesn't abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do not apply to
>>>>>>>>>>>>>>>>>>>>>>>>> what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of the input to H is
>>>>>>>>>>>>>>>>>>>>>>>> determined by the UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue with a
>>>>>>>>>>>>>>>>>>>>>>> deductive logical premise.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H doesn't go to H.Qn, so H
>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver making sure to always
>>>>>>>>>>>>>>>>>>>>> change the subject rather than directly address the
>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT change the
>>>>>>>>>>>>>>>>>>>> subject, I pointed out an error in your statement.
>>>>>>>>>>>>>>>>>>>> You seem to be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When testing whether or not one assertion logically
>>>>>>>>>>>>>>>>>>> follows from another the premises are always "given"
>>>>>>>>>>>>>>>>>>> to be true even if they are false.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are claiming.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is unsound.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We are not yet looking at soundness we are looking at
>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>> It is true that (2) logically follows from (1).
>>>>>>>>>>>>>>>>> We can't move on from this one point until we have
>>>>>>>>>>>>>>>>> mutual agreement.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Very strange then, why are you arguing about that which
>>>>>>>>>>>>>>>> was accepted unless you disagree to the conditions that
>>>>>>>>>>>>>>>> they were accepted under?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It has long been accepted that the under the
>>>>>>>>>>>>>>>> hypothetical condition where H can actually determine
>>>>>>>>>>>>>>>> that the UTM will run forever, it is correct (and in
>>>>>>>>>>>>>>>> fact needed to be correct) for H to go to H.Qn and say
>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated INPUT to
>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Under the definition that 'correctly simulated input' is
>>>>>>>>>>>>>> as determined by a UTM, not H (if it aborts its simulation).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is only stipulated to be correct other details are
>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>
>>>>>>>>>>>> That isn't a 'stipulation', that is a DEFINITION.
>>>>>>>>>>>>
>>>>>>>>>>>> This is obviously your attempt at being a weasel.
>>>>>>>>>>>>
>>>>>>>>>>>> The DEFINITION of correct simulation is the results of a UTM
>>>>>>>>>>>> simulating the input.
>>>>>>>>>>>>
>>>>>>>>>>>> Any deviaiton in this means you are just eating your POOP.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> It also does not presume that H CAN determine that this
>>>>>>>>>>>>>> condition exists, so it would be correct, but H might not
>>>>>>>>>>>>>> be able to decide to do so. So it may be correct for it to
>>>>>>>>>>>>>> do so, but it might not actually be able to do it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There is also the case you tend to ignore that you start
>>>>>>>>>>>>>> with an H that is defined to NOT abort, but you try to use
>>>>>>>>>>>>>> (2) to claim that it now can abort, the H is (2) must be
>>>>>>>>>>>>>> the same H that the H^ in (1) was built form
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> All of these restrictions are actually in the actual
>>>>>>>>>>>>>> meaning of the words you are using, from the context of
>>>>>>>>>>>>>> the problem, but I state them because knowing you, you are
>>>>>>>>>>>>>> going to try to break that restrictions.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> This seems to be the very first time that you actually paid
>>>>>>>>>>>>> close attention, good jo
>>>>>>>>>>>>>
>>>>>>>>>>>>>> As I asked, how is that different from the statement of
>>>>>>>>>>>>>> the requirements on H?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N
>>>>>>>>>>>>> is either the number of steps that it takes for its
>>>>>>>>>>>>> simulated input to reach its final state or the number of
>>>>>>>>>>>>> steps required for H to match an infinite behavior pattern
>>>>>>>>>>>>> proving that its simulated input would never reach its own
>>>>>>>>>>>>> final state. In this case H aborts the simulation of this
>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Note, The correct answer is NOT based on a simulation of N
>>>>>>>>>>>> steps, but a simulation by a UTM which will run until it halts.
>>>>>>>>>>>>
>>>>>>>>>>>> H needs to make ITS decision on the limited N step, so it
>>>>>>>>>>>> needs to prove that its answer matches.
>>>>>>>>>>>>
>>>>>>>>>>>> Remember, when we do this run, H is defined, and thus N is a
>>>>>>>>>>>> SPECIFIC number, not an 'arbitrary' number.
>>>>>>>>>>>>
>>>>>>>>>>>> You also will need to some how prove that a pattern exists
>>>>>>>>>>>> in N steps that correct dectect non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> This has been previously shown to be impossible, so you need
>>>>>>>>>>>> to actually come up with it or show an actual error in the
>>>>>>>>>>>> proof. You can't just assume it exists.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>
>>>>>>>>>>> (1) Premise: When embedded_H correctly determines its
>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>> embedded_H cannot possibly reach its final state
>>>>>>>>>>>
>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>>>>>>> reach its final state.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> WARNING, you are getting way into hypothecctica Unicoprn
>>>>>>>>>> Terretory, but lets unpack this statement.
>>>>>>>>>>
>>>>>>>>>> IF H can correctly deteremine (that means that there needs to
>>>>>>>>>> exist a finite algroithm to determine this case, and that this
>>>>>>>>>> result matches the behavior demonstrated by the definitional
>>>>>>>>>> UTM simulataion of this input), that the input will NEVER
>>>>>>>>>> reach it final state,
>>>>>>>>>>
>>>>>>>>>> Then yes, it is correct for H to report that its input can not
>>>>>>>>>> possible reach its final state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>
>>>>>>>>>> Note, that if H does this, then the proof that the input never
>>>>>>>>>> reached its final state must have included that fact that the
>>>>>>>>>> copy of H inside H^ will also do the exact same thing with the
>>>>>>>>>> exact same input.
>>>>>>>>>>
>>>>>>>>>> Also, to show the premise is True, you need to be able to
>>>>>>>>>> PROVE or actually provide the exact finite algorithm that it
>>>>>>>>>> used to detemine this fact.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>>>>> keep repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>
>>>>>>>
>>>>>>> On the basis that the pure simulation of N steps matches an
>>>>>>> infinitely repeating pattern embedded_H can correctly determine
>>>>>>> that this simulated input cannot possibly reach its final state
>>>>>>> whether or not embedded_H aborts its simulation of this input.
>>>>>>
>>>>>> WHAT N Step pattern shows that H^ <H^> is non-halting.
>>>>>>
>>>>>
>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would keep
>>>>> repeating:
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> If that is what happens, then obviously H never aborted its
>>>> simulation, so it CAN'T.
>>>>
>>>>
>>>
>>> As soon as embedded_H correctly recognizes this infinitely repeating
>>> pattern in its correct simulation of N steps of its input it is
>>> necessarily correct for it to report that that its simulated input
>>> cannot possibly ever reach its halt state.
>>
>> Only if it proved that it was correct if it does abort and go to H.Qn,
>> which it can't.
> With logical entailment the conclusion follows from the premise(s) by
> logical necessity.
>
> (1) As soon as embedded_H correctly recognizes this infinitely repeating
> pattern in its correct simulation of N steps of its input


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

<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 24 Jan 2022 21:45:25 -0600
Date: Mon, 24 Jan 2022 21:45:23 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <87mHJ.22633$dG7.7407@fx47.iad>
<GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
<wSmHJ.53088$Y01.31344@fx45.iad>
<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
<aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <3dJHJ.17533$f04.698@fx23.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
Lines: 507
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9nhIeSxdV8ZMURuc/YOG/VrWDTZQb+/TCh0AUOtht6zzYt951+0VWic1UxEn0aoYf4rmzmK6FI4Z7pT!nhhI1EKzf+E3an78r/fXCctFb87b5+sL7is1gMEVVz5BfvdvF98irupBBT4gBLD9BHimqk+xbRED
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 28129
 by: olcott - Tue, 25 Jan 2022 03:45 UTC

On 1/24/2022 8:26 PM, Richard Damon wrote:
> On 1/24/22 9:11 PM, olcott wrote:
>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>
>>> On 1/24/22 8:32 PM, olcott wrote:
>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is true for infinite loops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion, infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation and all other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non halting inputs:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to any simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach the final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this simulated input in any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always correct for the simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and transition to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can you PROVE that statement, or is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this just one of your false 'self
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> evident truth'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that x86 language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that its easy to match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55              push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec            mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe            jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do one case does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove that the same method works
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on all, particularly harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you serving Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does NOT show up in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE lies by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the input includes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a copy of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ -> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and for H^ <H^> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must be true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because we know that the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an Turing Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out of your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that IF the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider does abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input based on some condition,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it is no longer a source of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth for the halting status of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the input stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, which H are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, then H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of the input WILL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at H^.Qn, so H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT ENOUGH TO GET
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS. IT CAN BE VERIFIED AS COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON THE BASIS OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this is complete prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state (when simulated by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H) then, YES, H can go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological self-reference' in H^,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of <H^> <H^> that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.Qn, will BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, become a halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated INPUT that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state anyway. YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I said there is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no pattern that H use to detect that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> won't halt, as any pattern that H uses to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will be WRONG for H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as if H goes to H.Qn, then H^ also goes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have only proved that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the case where H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a box of rocks
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (or perhaps you are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I never mentioned
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the word: "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much dumber than a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well (you nearly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> passed the Turing test) it took me this long
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that you are not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is the same as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H never reaches a final state
>>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H doesn't abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do not apply to
>>>>>>>>>>>>>>>>>>>>>>>>>> what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of the input to H is
>>>>>>>>>>>>>>>>>>>>>>>>> determined by the UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue with a
>>>>>>>>>>>>>>>>>>>>>>>> deductive logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H doesn't go to H.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver making sure to always
>>>>>>>>>>>>>>>>>>>>>> change the subject rather than directly address
>>>>>>>>>>>>>>>>>>>>>> the point at hand.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT change the
>>>>>>>>>>>>>>>>>>>>> subject, I pointed out an error in your statement.
>>>>>>>>>>>>>>>>>>>>> You seem to be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When testing whether or not one assertion logically
>>>>>>>>>>>>>>>>>>>> follows from another the premises are always "given"
>>>>>>>>>>>>>>>>>>>> to be true even if they are false.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are claiming.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is unsound.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We are not yet looking at soundness we are looking at
>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>> It is true that (2) logically follows from (1).
>>>>>>>>>>>>>>>>>> We can't move on from this one point until we have
>>>>>>>>>>>>>>>>>> mutual agreement.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Very strange then, why are you arguing about that which
>>>>>>>>>>>>>>>>> was accepted unless you disagree to the conditions that
>>>>>>>>>>>>>>>>> they were accepted under?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It has long been accepted that the under the
>>>>>>>>>>>>>>>>> hypothetical condition where H can actually determine
>>>>>>>>>>>>>>>>> that the UTM will run forever, it is correct (and in
>>>>>>>>>>>>>>>>> fact needed to be correct) for H to go to H.Qn and say
>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated INPUT to
>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Under the definition that 'correctly simulated input' is
>>>>>>>>>>>>>>> as determined by a UTM, not H (if it aborts its simulation).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is only stipulated to be correct other details are
>>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That isn't a 'stipulation', that is a DEFINITION.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is obviously your attempt at being a weasel.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The DEFINITION of correct simulation is the results of a
>>>>>>>>>>>>> UTM simulating the input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any deviaiton in this means you are just eating your POOP.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It also does not presume that H CAN determine that this
>>>>>>>>>>>>>>> condition exists, so it would be correct, but H might not
>>>>>>>>>>>>>>> be able to decide to do so. So it may be correct for it
>>>>>>>>>>>>>>> to do so, but it might not actually be able to do it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There is also the case you tend to ignore that you start
>>>>>>>>>>>>>>> with an H that is defined to NOT abort, but you try to
>>>>>>>>>>>>>>> use (2) to claim that it now can abort, the H is (2) must
>>>>>>>>>>>>>>> be the same H that the H^ in (1) was built form
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All of these restrictions are actually in the actual
>>>>>>>>>>>>>>> meaning of the words you are using, from the context of
>>>>>>>>>>>>>>> the problem, but I state them because knowing you, you
>>>>>>>>>>>>>>> are going to try to break that restrictions.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This seems to be the very first time that you actually
>>>>>>>>>>>>>> paid close attention, good jo
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As I asked, how is that different from the statement of
>>>>>>>>>>>>>>> the requirements on H?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N
>>>>>>>>>>>>>> is either the number of steps that it takes for its
>>>>>>>>>>>>>> simulated input to reach its final state or the number of
>>>>>>>>>>>>>> steps required for H to match an infinite behavior pattern
>>>>>>>>>>>>>> proving that its simulated input would never reach its own
>>>>>>>>>>>>>> final state. In this case H aborts the simulation of this
>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, The correct answer is NOT based on a simulation of N
>>>>>>>>>>>>> steps, but a simulation by a UTM which will run until it
>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H needs to make ITS decision on the limited N step, so it
>>>>>>>>>>>>> needs to prove that its answer matches.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Remember, when we do this run, H is defined, and thus N is
>>>>>>>>>>>>> a SPECIFIC number, not an 'arbitrary' number.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You also will need to some how prove that a pattern exists
>>>>>>>>>>>>> in N steps that correct dectect non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This has been previously shown to be impossible, so you
>>>>>>>>>>>>> need to actually come up with it or show an actual error in
>>>>>>>>>>>>> the proof. You can't just assume it exists.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>
>>>>>>>>>>>> (1) Premise: When embedded_H correctly determines its
>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>> embedded_H cannot possibly reach its final state
>>>>>>>>>>>>
>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>> WARNING, you are getting way into hypothecctica Unicoprn
>>>>>>>>>>> Terretory, but lets unpack this statement.
>>>>>>>>>>>
>>>>>>>>>>> IF H can correctly deteremine (that means that there needs to
>>>>>>>>>>> exist a finite algroithm to determine this case, and that
>>>>>>>>>>> this result matches the behavior demonstrated by the
>>>>>>>>>>> definitional UTM simulataion of this input), that the input
>>>>>>>>>>> will NEVER reach it final state,
>>>>>>>>>>>
>>>>>>>>>>> Then yes, it is correct for H to report that its input can
>>>>>>>>>>> not possible reach its final state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>>
>>>>>>>>>>> Note, that if H does this, then the proof that the input
>>>>>>>>>>> never reached its final state must have included that fact
>>>>>>>>>>> that the copy of H inside H^ will also do the exact same
>>>>>>>>>>> thing with the exact same input.
>>>>>>>>>>>
>>>>>>>>>>> Also, to show the premise is True, you need to be able to
>>>>>>>>>>> PROVE or actually provide the exact finite algorithm that it
>>>>>>>>>>> used to detemine this fact.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>>>>>> keep repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> On the basis that the pure simulation of N steps matches an
>>>>>>>> infinitely repeating pattern embedded_H can correctly determine
>>>>>>>> that this simulated input cannot possibly reach its final state
>>>>>>>> whether or not embedded_H aborts its simulation of this input.
>>>>>>>
>>>>>>> WHAT N Step pattern shows that H^ <H^> is non-halting.
>>>>>>>
>>>>>>
>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>> keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> If that is what happens, then obviously H never aborted its
>>>>> simulation, so it CAN'T.
>>>>>
>>>>>
>>>>
>>>> As soon as embedded_H correctly recognizes this infinitely repeating
>>>> pattern in its correct simulation of N steps of its input it is
>>>> necessarily correct for it to report that that its simulated input
>>>> cannot possibly ever reach its halt state.
>>>
>>> Only if it proved that it was correct if it does abort and go to
>>> H.Qn, which it can't.
>> With logical entailment the conclusion follows from the premise(s) by
>> logical necessity.
>>
>> (1) As soon as embedded_H correctly recognizes this infinitely
>> repeating pattern in its correct simulation of N steps of its input
>
> Which makes the falicay of assuming there is a CORRECT pattern for H to
> detect in H^, and that H has the ability to detect it.
>


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

<fsKHJ.15868$yS2.11625@fx20.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx20.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
<wSmHJ.53088$Y01.31344@fx45.iad>
<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
<aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 532
Message-ID: <fsKHJ.15868$yS2.11625@fx20.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: Mon, 24 Jan 2022 22:50:35 -0500
X-Received-Bytes: 29057
 by: Richard Damon - Tue, 25 Jan 2022 03:50 UTC

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


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

<ssnshc$jfl$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Date: Mon, 24 Jan 2022 21:58:33 -0600
Organization: A noiseless patient Spider
Lines: 508
Message-ID: <ssnshc$jfl$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me> <wSmHJ.53088$Y01.31344@fx45.iad>
<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
<aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 25 Jan 2022 03:58:36 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="8c335e1b8fadcf970d77afd13dc52c70";
logging-data="19957"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/cO+P5JL6RC5Kj57URAYY2"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Cancel-Lock: sha1:HXYulFoCuUg30VG+sO8Bsatzm6I=
In-Reply-To: <fsKHJ.15868$yS2.11625@fx20.iad>
Content-Language: en-US
 by: olcott - Tue, 25 Jan 2022 03:58 UTC

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


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

<7QKHJ.3189$rU.3101@fx34.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx34.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <wSmHJ.53088$Y01.31344@fx45.iad>
<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
<aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ssnshc$jfl$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 532
Message-ID: <7QKHJ.3189$rU.3101@fx34.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: Mon, 24 Jan 2022 23:16:02 -0500
X-Received-Bytes: 30577
 by: Richard Damon - Tue, 25 Jan 2022 04:16 UTC

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


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

<5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 24 Jan 2022 22:20:00 -0600
Date: Mon, 24 Jan 2022 22:19:58 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
<aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7QKHJ.3189$rU.3101@fx34.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
Lines: 556
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZygWkDDSfk7kDe1M4MKABX0lU1rYoTqNXvjUcg/LYjz2Ql7TjiLk1k4ti+GWOdGE4sWLhzhG8SpVy7S!s3jgGTIVACT3bUf2oLoSavQoe5M9OR5T0W21e8xVie/SBWPyuHMKzs159QCeZ1fg4SLyQtekqg90
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 32104
 by: olcott - Tue, 25 Jan 2022 04:19 UTC

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


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

<EYKHJ.8824$2V.6890@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx07.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <aGnHJ.254127$VS2.43875@fx44.iad>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 580
Message-ID: <EYKHJ.8824$2V.6890@fx07.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: Mon, 24 Jan 2022 23:25:07 -0500
X-Received-Bytes: 33265
 by: Richard Damon - Tue, 25 Jan 2022 04:25 UTC

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


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

<_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 24 Jan 2022 22:28:20 -0600
Date: Mon, 24 Jan 2022 22:28:18 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <EYKHJ.8824$2V.6890@fx07.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
Lines: 558
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-yrk6eesGKTFUUn6DMXX38nRtHYezuJynP1xnrEXAqNMJHhUQjcDEFtzT+fkA+cykTYLi6h+FaGP9sdh!d7rstn/+1Y8KlBxdaGyWcxAplUokoO+j5wr2l6cj18aXVpU1TLK9NsAbHSDbErkyJNlyGz+Me4KT
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 32906
 by: olcott - Tue, 25 Jan 2022 04:28 UTC

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


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

<DoLHJ.5615$QO.1124@fx29.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx29.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <sYnHJ.6193$9O.3928@fx12.iad>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 580
Message-ID: <DoLHJ.5615$QO.1124@fx29.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: Mon, 24 Jan 2022 23:54:59 -0500
X-Received-Bytes: 34088
 by: Richard Damon - Tue, 25 Jan 2022 04:54 UTC

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


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

<dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 24 Jan 2022 23:04:41 -0600
Date: Mon, 24 Jan 2022 23:04:39 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
<NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <DoLHJ.5615$QO.1124@fx29.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
Lines: 587
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WJkejtVJXTClBdxes/vQ8NireIjzI6dTyghh5v5wcgqw78hvTxgNSQCUh3WJUARVgzubc0Uw191OmfA!sSnRqnGKxK/rQ8hMD1rw1BJR3fZmg2ZSs7ddqvRMv15mtWbp3D06w9DoT+NwZE9A+D38CKkwlXJT
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 35045
 by: olcott - Tue, 25 Jan 2022 05:04 UTC

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


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

<oHLHJ.138400$Gco3.122595@fx01.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <NmoHJ.22635$dG7.20402@fx47.iad>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 616
Message-ID: <oHLHJ.138400$Gco3.122595@fx01.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 25 Jan 2022 00:15:00 -0500
X-Received-Bytes: 36487
 by: Richard Damon - Tue, 25 Jan 2022 05:15 UTC

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


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

<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 24 Jan 2022 23:27:51 -0600
Date: Mon, 24 Jan 2022 23:27:49 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
<0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <oHLHJ.138400$Gco3.122595@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com>
Lines: 631
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-yO4ViyKq6Y8rj77PoPecL77BiuOJY2f1uXOyircXLukFXgvTKiwaBVve5APobyLDT8cDSzA+QdfPl1T!AEvwhZMbys8DIN6jQz4FsBvAobb+mrjX0MlTO3aDjw/03bzVcjY2MHLCeh4kLgHWmE8UNfx8w0AR
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 37810
 by: olcott - Tue, 25 Jan 2022 05:27 UTC

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


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

<7zRHJ.3234$rU.2663@fx34.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx34.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <0_oHJ.254128$VS2.188172@fx44.iad>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 649
Message-ID: <7zRHJ.3234$rU.2663@fx34.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 25 Jan 2022 06:55:47 -0500
X-Received-Bytes: 39040
 by: Richard Damon - Tue, 25 Jan 2022 11:55 UTC

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


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

<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 25 Jan 2022 08:44:10 -0600
Date: Tue, 25 Jan 2022 08:44:09 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me>
<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7zRHJ.3234$rU.2663@fx34.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
Lines: 679
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1RuiVfzdSQNirHwjuwoZSJem9krQ0Oi9htSOTpmJxQwY2CjBGBHslnEHEBeLyBPmJ26zkU3+c2tk2Ag!8DH3Ddp6y5/B+QT0SC3LFQkRIR4aBSy45zhr3exY+cxgXqxwXi87OGPwrqLUxbVYwTAyg5aTxGQF
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 41176
X-Received-Bytes: 41358
 by: olcott - Tue, 25 Jan 2022 14:44 UTC

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


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

<sspjnc$1lo2$1@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: SteveMc1...@hotmail.com (Steve)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ Linz Proof ]
Date: Tue, 25 Jan 2022 11:40:26 -0800
Organization: Aioe.org NNTP Server
Message-ID: <sspjnc$1lo2$1@gioia.aioe.org>
References: <ssh8vu$4c0$1@dont-email.me>
Reply-To: SteveMc1974@hotmail.com
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="55042"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Content-Language: en-US
X-Notice: Filtered by postfilter v. 0.9.2
 by: Steve - Tue, 25 Jan 2022 19:40 UTC

On 1/22/2022 7:48 AM, olcott wrote:
> Halting problem undecidability and infinitely nested simulation (V3)

) Ceaseless nonsensical blither.

) Get a brain soon.

) Adios moron.

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

<yW%HJ.7148$h91.5996@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <CspHJ.6567$uP.5786@fx16.iad>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 707
Message-ID: <yW%HJ.7148$h91.5996@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: Tue, 25 Jan 2022 18:43:26 -0500
X-Received-Bytes: 42776
 by: Richard Damon - Tue, 25 Jan 2022 23:43 UTC

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


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

<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 25 Jan 2022 18:03:06 -0600
Date: Tue, 25 Jan 2022 18:03:05 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me>
<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <yW%HJ.7148$h91.5996@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
Lines: 728
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Mk8tsfNBfEsKJl0Xr/i+NL+nr+U/ZPxITLrSsa/gXUTq5rYGJ0GN+HAHnUsdsVM5tqeGa7g/udqlYZc!wV7dQRjrapSoBevhAVC0nwbOkOZlZPU035lTnzE2UXDxbANTX46z04CK1H+l6yFejUaK4iQkrLN4
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 44546
 by: olcott - Wed, 26 Jan 2022 00:03 UTC

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


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

<Bq0IJ.313197$qz4.269632@fx97.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx97.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <z9qHJ.3181$rU.2919@fx34.iad>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 756
Message-ID: <Bq0IJ.313197$qz4.269632@fx97.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 25 Jan 2022 19:17:36 -0500
X-Received-Bytes: 46136
 by: Richard Damon - Wed, 26 Jan 2022 00:17 UTC

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


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

<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 25 Jan 2022 19:11:38 -0600
Date: Tue, 25 Jan 2022 19:11:37 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me>
<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
<qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <Bq0IJ.313197$qz4.269632@fx97.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
Lines: 801
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JH2VFlACuigyZJ480tJDuVDLDSF28rOKXPt0lExIAeEOHApbf7TlGMYTpJhNY4M93F0PDXQgFoFWljK!+qXwvMPBaLCWSXzkkyoojQ3Hi8hu5h32puKsuAZ+6c45ofkWstN/KsYLr8p8IRnon5OCeI8bQ2WY
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 48949
 by: olcott - Wed, 26 Jan 2022 01:11 UTC

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


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

<UW1IJ.38990$i%.5899@fx04.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx04.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <qWGHJ.11522$2W.7884@fx36.iad>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 879
Message-ID: <UW1IJ.38990$i%.5899@fx04.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 25 Jan 2022 21:00:19 -0500
X-Received-Bytes: 53026
 by: Richard Damon - Wed, 26 Jan 2022 02:00 UTC

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


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

<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 25 Jan 2022 21:09:48 -0600
Date: Tue, 25 Jan 2022 21:09:44 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
<KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <UW1IJ.38990$i%.5899@fx04.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
Lines: 897
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-HoGZVInUFRPNChB+0PTOlYAPuyoJjvjOmJ+DivGlNOYtTC9G2G5dUeHAqp40PvvVVFbgjCngeXRQZUL!YprcCRjfimtura0VHa34qYKnwmqBSUPDHq82J2z1JGBYz7XBVIC1DCxqm6elwGjOuaNlsORJUS2X
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 54703
 by: olcott - Wed, 26 Jan 2022 03:09 UTC

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


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

<Dq3IJ.17537$f04.1511@fx23.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx23.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <KPHHJ.311933$qz4.109480@fx97.iad>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 963
Message-ID: <Dq3IJ.17537$f04.1511@fx23.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 25 Jan 2022 22:42:27 -0500
X-Received-Bytes: 57729
 by: Richard Damon - Wed, 26 Jan 2022 03:42 UTC

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


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

<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 25 Jan 2022 21:54:38 -0600
Date: Tue, 25 Jan 2022 21:54:36 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
<1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <Dq3IJ.17537$f04.1511@fx23.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
Lines: 867
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ebBkdaz6gQ7G+5aEtLBzek1u+vOdII4WhzFhWu0iZ5bsopUW1WW91aQQ6HZxbM/2791yNEJY+GsnsKZ!rTClPwjibF5ljKjeZ7hJF6ERLB1ExYGqAfE5wItF0Et0BUpsXFbNQbQvPTVe/bb379Jz4OYFRStd
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 55414
 by: olcott - Wed, 26 Jan 2022 03:54 UTC

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


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

<S64IJ.27704$7U.16191@fx42.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <1UIHJ.282256$1d1.28846@fx99.iad>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 940
Message-ID: <S64IJ.27704$7U.16191@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 25 Jan 2022 23:29:37 -0500
X-Received-Bytes: 59623
 by: Richard Damon - Wed, 26 Jan 2022 04:29 UTC

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


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

<8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 25 Jan 2022 22:36:31 -0600
Date: Tue, 25 Jan 2022 22:36:29 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
<3dJHJ.17533$f04.698@fx23.iad>
<eICdne89nPPI73L8nZ2dnUU7-V3NnZ2d@giganews.com>
<fsKHJ.15868$yS2.11625@fx20.iad> <ssnshc$jfl$1@dont-email.me>
<7QKHJ.3189$rU.3101@fx34.iad> <5aOdnY1a4_Xt53L8nZ2dnUU7-SvNnZ2d@giganews.com>
<EYKHJ.8824$2V.6890@fx07.iad> <_u-dnQzrFvT54XL8nZ2dnUU7-XednZ2d@giganews.com>
<DoLHJ.5615$QO.1124@fx29.iad> <dJ6dnbZdb_R0GXL8nZ2dnUU7-W-dnZ2d@giganews.com>
<oHLHJ.138400$Gco3.122595@fx01.iad>
<2sWdndujvZPKF3L8nZ2dnUU7-V_NnZ2d@giganews.com> <7zRHJ.3234$rU.2663@fx34.iad>
<qOWdnYg47f8nkW38nZ2dnUU7-XvNnZ2d@giganews.com>
<yW%HJ.7148$h91.5996@fx48.iad>
<pMmdnUSKnpgnEm38nZ2dnUU7-bnNnZ2d@giganews.com>
<Bq0IJ.313197$qz4.269632@fx97.iad>
<GbOdnRAEI7BXAm38nZ2dnUU7-XnNnZ2d@giganews.com>
<UW1IJ.38990$i%.5899@fx04.iad>
<1IudnXCb-OzhJm38nZ2dnUU7-bvNnZ2d@giganews.com>
<Dq3IJ.17537$f04.1511@fx23.iad>
<ubqdneNkd89jWG38nZ2dnUU7-SnNnZ2d@giganews.com>
<S64IJ.27704$7U.16191@fx42.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <S64IJ.27704$7U.16191@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8eydnSpcWIVSUm38nZ2dnUU7-XvNnZ2d@giganews.com>
Lines: 953
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FjDeAjKl0sayQ+s9o7CszNi3uzjejJXpsBl8+IlkdURtkct4Y1wyf1IP3TWZ2tSJx3pAnFqHoiLF38Y!MBYqp4lBUFCPaSIlIkCaQyb5n57Kq6+cWqhey5i4aH2KzfmKG6R+684ypah6d1C6apmWo9/8V6tD
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 61339
 by: olcott - Wed, 26 Jan 2022 04:36 UTC

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


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

rocksolid light 0.9.7
clearnet tor