Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Hacking's just another word for nothing left to kludge.


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

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 [ Ignorant or Dishonest ](typo)

<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!3.eu.feeder.erje.net!2.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 23 Jan 2022 17:16:56 -0600
Date: Sun, 23 Jan 2022 17:16:55 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <6clHJ.303815$qz4.185496@fx97.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
Lines: 183
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SUk7dvJi+lgpCXzIXXXiDWSrGDEN5u+Vsyarg3kUaQJVwB7f2nwwcwYf6zVc+09ju4/H4Yov0wDRcx5!dalyOXF9teX3QWABEUA3EcivbOVgWRU4ZkEAmeqOHHbWrKHYqFabSdptozegg01qp9jfiDn90U/V
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: 9467
 by: olcott - Sun, 23 Jan 2022 23:16 UTC

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:


Click here to read the complete article
Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ](typo)

<aRlHJ.23755$XU.7495@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ](typo)
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 203
Message-ID: <aRlHJ.23755$XU.7495@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 18:50:30 -0500
X-Received-Bytes: 10097
 by: Richard Damon - Sun, 23 Jan 2022 23:50 UTC

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


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

<OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!2.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 23 Jan 2022 18:00:31 -0600
Date: Sun, 23 Jan 2022 18:00:30 -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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <aRlHJ.23755$XU.7495@fx38.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
Lines: 196
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-9UWJUHhwGEzOIieSFFuf5fxUwQOLTzWs/LVM2zsxHzgC/pgEFvc8Zqc6U7ND+iDbmyBfbnly8JZ4RhL!Kdx6mAR/GoxrJRSQxJCtroQkM/XI4HVFWBmSCGNeEoOlOnAHn3PZ5+J24uklyb92Twy1+JYM7mBB
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: 10139
 by: olcott - Mon, 24 Jan 2022 00:00 UTC

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.


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

<87mHJ.22633$dG7.7407@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 201
Message-ID: <87mHJ.22633$dG7.7407@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 19:09:40 -0500
X-Received-Bytes: 10175
 by: Richard Damon - Mon, 24 Jan 2022 00:09 UTC

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


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

<GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!2.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 23 Jan 2022 18:26:01 -0600
Date: Sun, 23 Jan 2022 18:25:52 -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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
<87mHJ.22633$dG7.7407@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87mHJ.22633$dG7.7407@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
Lines: 223
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sf2zDbK0kRxB55xptDZINiV69mgG1u6ey9bhpyHH8ha5PGw5ORekBVwRD6zAr95ZoCDZt1r8bwgpoJ4!wn6OzieMyAdHFdSjakn+yg/sB/GN8qodeV2iGQrfBvx/DlopJRwLkYjw9JiFoX8mEgW7c03JkcoX
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: 11067
 by: olcott - Mon, 24 Jan 2022 00:25 UTC

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


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

<wSmHJ.53088$Y01.31344@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
<87mHJ.22633$dG7.7407@fx47.iad>
<GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 244
Message-ID: <wSmHJ.53088$Y01.31344@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 20:00:12 -0500
X-Received-Bytes: 11869
 by: Richard Damon - Mon, 24 Jan 2022 01:00 UTC

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.


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

<KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 23 Jan 2022 19:10:21 -0600
Date: Sun, 23 Jan 2022 19:10:20 -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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<OMqdnSfhrYOCcXD8nZ2dnUU7-T3NnZ2d@giganews.com>
<87mHJ.22633$dG7.7407@fx47.iad>
<GNqdnSg7oc-Eb3D8nZ2dnUU7-XHNnZ2d@giganews.com>
<wSmHJ.53088$Y01.31344@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <wSmHJ.53088$Y01.31344@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
Lines: 236
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-HzE4iNwkPcSC7BF+tyA2kFwzmoDWUGpo1VnZKeQURdg23p1ASZbwj8khH8VyOb3kGO/c+1itVfcfptH!m9hN1MUgWvwwUUBoIWPd4uHkUpaz/pU845klwpEBdzA3ZHCcTta6RqZ1k7fhu4E57m52U+Dd7uEF
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: 12163
 by: olcott - Mon, 24 Jan 2022 01:10 UTC

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


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

<aGnHJ.254127$VS2.43875@fx44.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <KJ-dnWCshr7gYXD8nZ2dnUU7-TXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 301
Message-ID: <aGnHJ.254127$VS2.43875@fx44.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 20:55:18 -0500
X-Received-Bytes: 15032
 by: Richard Damon - Mon, 24 Jan 2022 01:55 UTC

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.


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

<u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!3.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 23 Jan 2022 20:03:46 -0600
Date: Sun, 23 Jan 2022 20:03:45 -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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <aGnHJ.254127$VS2.43875@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com>
Lines: 245
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZElv0cRUUisHKNdBZ7+xv4Jp5/uLWvtSqHdhdTzX9ZgCq3YmD6ebijM3ravTJbZBQXIq4pa4ilMmu5f!YEQTVsTzsaGBl8CzeTh7K8JwpPeoUdWAv5CjiH9sbK8S8ROaCS6PfHE/2uolnE0A0xuxMRdoUKCb
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: 12773
 by: olcott - Mon, 24 Jan 2022 02:03 UTC

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


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

<sYnHJ.6193$9O.3928@fx12.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <u9Kdna64maOflHP8nZ2dnUU7-U_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 275
Message-ID: <sYnHJ.6193$9O.3928@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 21:14:48 -0500
X-Received-Bytes: 13968
 by: Richard Damon - Mon, 24 Jan 2022 02:14 UTC

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


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

<ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 23 Jan 2022 20:29:53 -0600
Date: Sun, 23 Jan 2022 20:29:53 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sYnHJ.6193$9O.3928@fx12.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
Lines: 272
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YdJwKRA467KydULQ+Jz+JLIzkC7V+soCHvp/dgPze1uSV+7wB73dZEikWbXXQ0ubVKR0po4mmy504k0!2MVlbCOJf57hhwlRQRIJ0VmCu4N1fZ6NAimCAEabXEQhEVqByCOYkyaLEK6Em8pN+yH2Y6vuWkxt
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: 13997
 by: olcott - Mon, 24 Jan 2022 02:29 UTC

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


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

<NmoHJ.22635$dG7.20402@fx47.iad>

 copy mid

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

 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!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ofSdnRQ7qYe8knP8nZ2dnUU7-XHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 282
Message-ID: <NmoHJ.22635$dG7.20402@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 21:42:52 -0500
X-Received-Bytes: 14686
 by: Richard Damon - Mon, 24 Jan 2022 02:42 UTC

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


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

<mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>

 copy mid

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

 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: Sun, 23 Jan 2022 21:10:02 -0600
Date: Sun, 23 Jan 2022 21:10:00 -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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <NmoHJ.22635$dG7.20402@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
Lines: 308
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XgcBF2Ga2T1YiaR+3LWkjyO4qvxEF3Gk87PxSGSQPpocB3iTycjJqIucbT/778LQqKRA/XUo8r3/eGA!m7Dbck66JV/AGa4Y2kTajTpL6C7dtceDXKkL6k3Jk9coW4qePRQi6KBNHY5wyf035qCQop88yW6m
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: 16098
 by: olcott - Mon, 24 Jan 2022 03:10 UTC

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


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

<0_oHJ.254128$VS2.188172@fx44.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.neodome.net!weretis.net!feeder8.news.weretis.net!npeer.as286.net!npeer-ng0.as286.net!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <UN_GJ.275715$1d1.2334@fx99.iad>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <mZSdnWvt5_EXhXP8nZ2dnUU7-Q_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 334
Message-ID: <0_oHJ.254128$VS2.188172@fx44.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 22:24:43 -0500
X-Received-Bytes: 17041
 by: Richard Damon - Mon, 24 Jan 2022 03:24 UTC

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.


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

<qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com>

 copy mid

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

 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: Sun, 23 Jan 2022 21:40:13 -0600
Date: Sun, 23 Jan 2022 21:40:12 -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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<wYOdnZZx16xyR3H8nZ2dnUU7-afNnZ2d@giganews.com> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <0_oHJ.254128$VS2.188172@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com>
Lines: 354
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PZ0Q2A2JFbALyD6ErNabfNbhY1Xp7GJXnk9lleRiDCRoZdicyN6d8QURKqBDmpZKqlXs7lkmfNRVjA1!/mNj7ne1VtmuiSL+30z7NWTRNCabnKsgrd1fd5F38h4pfI29MzraFpU+SEtPftCEb7m7TZXuVzT4
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: 18132
 by: olcott - Mon, 24 Jan 2022 03:40 UTC

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


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

<CspHJ.6567$uP.5786@fx16.iad>

 copy mid

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

 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.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.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 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <a25HJ.3979$CW.1138@fx17.iad>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qvWdncTddvgAgnP8nZ2dnUU7-QHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 382
Message-ID: <CspHJ.6567$uP.5786@fx16.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 23 Jan 2022 22:57:22 -0500
X-Received-Bytes: 19567
 by: Richard Damon - Mon, 24 Jan 2022 03:57 UTC

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.


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

<ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com>

 copy mid

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

 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: Sun, 23 Jan 2022 22:17:38 -0600
Date: Sun, 23 Jan 2022 22:17:28 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.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>
<Z_ydnS3z8MehN3D8nZ2dnUU7-e3NnZ2d@giganews.com>
<zQiHJ.266154$np6.261295@fx46.iad> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <CspHJ.6567$uP.5786@fx16.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com>
Lines: 395
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-u9kpYcEBZ1+nLacpmQxfZfpZGtaKLvRT0LbFG1iad52UgXstCXeVmP/ERhALcUuohulkcMHfEIQ4R76!4WqZTfFujnyT6JrcseAOLt97FuHqXVT+47z/zGPBBviWL6Rkx1PhuTS9tMvD/XjJrEy2ZzVncNX9
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: 20257
 by: olcott - Mon, 24 Jan 2022 04:17 UTC

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


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

<z9qHJ.3181$rU.2919@fx34.iad>

 copy mid

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

 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!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.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> <zQiHJ.266154$np6.261295@fx46.iad>
<sski0q$oqi$1@dont-email.me> <kfkHJ.7205$zV.6163@fx43.iad>
<sskk6q$86p$1@dont-email.me> <JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ld2dnW-kzJX_tXP8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 412
Message-ID: <z9qHJ.3181$rU.2919@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: Sun, 23 Jan 2022 23:45:19 -0500
X-Received-Bytes: 21098
 by: Richard Damon - Mon, 24 Jan 2022 04:45 UTC

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 ⟨Ĥ⟩ ⟨Ĥ⟩...
>
>


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

<i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>

 copy mid

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

 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 09:03:17 -0600
Date: Mon, 24 Jan 2022 09:03:15 -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> <sski0q$oqi$1@dont-email.me>
<kfkHJ.7205$zV.6163@fx43.iad> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <z9qHJ.3181$rU.2919@fx34.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
Lines: 443
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XVxEZXAkx9PCVQIAyWZigtnwzcbwDXZM9SonNX0P0oS6hif3YHyADVn3/hLoiHkBL5ZGFJTrmT2SMrq!7hA9cG+j/QdwsiwXPniGmEYArfowhDDx8ATBDmhCngXIOV3AiZyDsVnIdah+1PA9Il/A6Mbjp29z
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: 23054
 by: olcott - Mon, 24 Jan 2022 15:03 UTC

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


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

<qWGHJ.11522$2W.7884@fx36.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx36.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <kfkHJ.7205$zV.6163@fx43.iad>
<sskk6q$86p$1@dont-email.me> <JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <i7qdnYQH-OUoInP8nZ2dnUU7-b3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 479
Message-ID: <qWGHJ.11522$2W.7884@fx36.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 24 Jan 2022 18:49:42 -0500
X-Received-Bytes: 24153
 by: Richard Damon - Mon, 24 Jan 2022 23:49 UTC

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.


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

<yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>

 copy mid

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

 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 18:09:39 -0600
Date: Mon, 24 Jan 2022 18:09:30 -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> <sskk6q$86p$1@dont-email.me>
<JPkHJ.266155$np6.131863@fx46.iad>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <qWGHJ.11522$2W.7884@fx36.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
Lines: 504
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-z18Q9/VMP+7y5nrMb3wdbpv4xV07q3yEhdDCsbf6yLttVqyrI2bzkvPcZiMsAtbTsFNEk0+ujTTpRcz!i/sDduceGBUWTWr1C3Hirdrzsip3pqw+wv0CY+5yXOrKbB+HkqX7ERtH9Ze58uYngYF9582qN4v5
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: 25641
 by: olcott - Tue, 25 Jan 2022 00:09 UTC

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


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

<KPHHJ.311933$qz4.109480@fx97.iad>

 copy mid

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

 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!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>
<rrGdnV_ySKRmR3D8nZ2dnUU7-Y_NnZ2d@giganews.com>
<6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <yuWdnWDd8speonL8nZ2dnUU7-cPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 548
Message-ID: <KPHHJ.311933$qz4.109480@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: Mon, 24 Jan 2022 19:50:50 -0500
X-Received-Bytes: 26880
 by: Richard Damon - Tue, 25 Jan 2022 00:50 UTC

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 ⟨Ĥ⟩ ⟨Ĥ⟩...


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

<OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>

 copy mid

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

 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 19:32:14 -0600
Date: Mon, 24 Jan 2022 19:32:12 -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> <6clHJ.303815$qz4.185496@fx97.iad>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <KPHHJ.311933$qz4.109480@fx97.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
Lines: 452
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JRuf9za/oZ4CqNbfQyy7UnZRn07bpGKb8HyhSecnpyrlqf547ScZ8DztUvyzRtOjIDfUKRCCv//OFKE!8mBmm5DZ+4tzExWsb619x7FlpvC9yRwYWOwCglGnuFdGpW3MUie2lIDnjIiiqAZSzlw8MUzeSFRf
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: 24625
 by: olcott - Tue, 25 Jan 2022 01:32 UTC

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


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

<1UIHJ.282256$1d1.28846@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Honest
Dialogue Begins ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<CMidnfXpKJh1fHD8nZ2dnUU7-QnNnZ2d@giganews.com>
<aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <OMGdndHAM9CDznL8nZ2dnUU7-YfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 503
Message-ID: <1UIHJ.282256$1d1.28846@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 24 Jan 2022 21:03:41 -0500
X-Received-Bytes: 26759
 by: Richard Damon - Tue, 25 Jan 2022 02:03 UTC

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.


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

<5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>

 copy mid

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

 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 20:11:49 -0600
Date: Mon, 24 Jan 2022 20:11:42 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.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> <aRlHJ.23755$XU.7495@fx38.iad>
<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>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <1UIHJ.282256$1d1.28846@fx99.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5p-dnZEaj-b4wXL8nZ2dnUU7-fHNnZ2d@giganews.com>
Lines: 468
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-2lFzSkXsBhAOnlEHnu8LT73aczrbRidUYoZU5KO0jgx+Fy+UqplCJxSKPQW0ad88W+ul0LQbecp01bR!Qf9//QXz55qBzlfJVpJ6A3F1N4QHmImMD973kHhMyXmmfLj0wKMthr0dtHZ3+JI6uwv72+mhI09T
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: 25955
 by: olcott - Tue, 25 Jan 2022 02:11 UTC

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.


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

rocksolid light 0.9.7
clearnet tor