Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Function reject.


devel / comp.theory / Re: Concise refutation of halting problem proofs V62 [ misconceptions ]

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

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

<AXEMJ.6305$4vG9.2509@fx19.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx19.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 308
Message-ID: <AXEMJ.6305$4vG9.2509@fx19.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 8 Feb 2022 20:39:43 -0500
X-Received-Bytes: 16107
 by: Richard Damon - Wed, 9 Feb 2022 01:39 UTC

On 2/8/22 7:31 PM, olcott wrote:
> On 2/8/2022 6:04 PM, Richard Damon wrote:
>> On 2/8/22 10:35 AM, olcott wrote:
>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H
>>>>>>>>>>>>>>>>>>>>> aborts its simulation and
>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the
>>>>>>>>>>>>>>>>>>>> case where the
>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem is
>>>>>>>>>>>>>>>>>>> undecidable. That is all that I need to refute these
>>>>>>>>>>>>>>>>>>> proofs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set
>>>>>>>>>>>>>>>>>>>> of patterns such
>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or matches
>>>>>>>>>>>>>>>>>>>> one of these
>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show
>>>>>>>>>>>>>>>>>>> that their counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to <H^>
>>>>>>>>>>>>>>>>>> <H^> goes to H.Qn, then by construction H^ <H^> goes
>>>>>>>>>>>>>>>>>> to H^.Qn, and halts, and since H, to be an accurate
>>>>>>>>>>>>>>>>>> Halt Decider, must only go to H,Qn if the machine its
>>>>>>>>>>>>>>>>>> input represents will never halt. They you also don't
>>>>>>>>>>>>>>>>>> seem to understand that the computaton that <H^> <H^>
>>>>>>>>>>>>>>>>>> represents IS H^ applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing
>>>>>>>>>>>>>>>>>> pile of unsound logic based on wrong definitions that
>>>>>>>>>>>>>>>>>> have hoodwinked yourself into thinking you have shown
>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are so good at doing this that you have gaslighted
>>>>>>>>>>>>>>>>>> yourself so you can't actually understand what actual
>>>>>>>>>>>>>>>>>> Truth is.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>>>> understand that you are wrong and never will because
>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And you clearly don't know enough Computation Theory to
>>>>>>>>>>>>>>>> talk about it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders they
>>>>>>>>>>>>>>>>> are only accountable for computing the mapping from
>>>>>>>>>>>>>>>>> their input finite strings to an accept or reject state
>>>>>>>>>>>>>>>>> on the basis of whether or not their correctly
>>>>>>>>>>>>>>>>> simulated input could ever reach its final state: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM which BY
>>>>>>>>>>>>>>>> DEFINITION exactly matches the behavior of Computation
>>>>>>>>>>>>>>>> that it is representation of, which for <H^> <H^> is H^
>>>>>>>>>>>>>>>> applied to <H^>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps for
>>>>>>>>>>>>>>> the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to
>>>>>>>>>>>>>>> transition to ⟨Ĥ⟩.qn then the input to embedded_H meets
>>>>>>>>>>>>>>> the Linz definition of a sequence of configurations that
>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and doesn't
>>>>>>>>>>>>>> reach a final state, then it shows its input never halts.
>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the same
>>>>>>>>>>>>> three iterations:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of steps,
>>>>>>>>>>>>> which proves that this input cannot possibly meet the Linz
>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>
>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> OK, so the only computatiopn that you show that does not
>>>>>>>>>>>> halt is H, so H can not be a decider.
>>>>>>>>>>>
>>>>>>>>>>> In the above example embedded_H simulates three iterations of
>>>>>>>>>>> nested simulation to match the infinitely nested simulation
>>>>>>>>>>> pattern.
>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is using
>>>>>>>>>> it will Halt,
>>>>>>>>>
>>>>>>>>> embedded_H only examines the actual behavior of its inputs as
>>>>>>>>> if its was a guard assigned to watch the front. If someone
>>>>>>>>> comes in the back door (non-inputs) embedded_H is not even
>>>>>>>>> allowed to pay attention.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>> behavior of H^ applied to <H^> you are lying about doing the
>>>>>>>> Halting Problem.
>>>>>>>>
>>>>>>>
>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing in
>>>>>>> the universe can possibly contradict the fact that the input
>>>>>>> specifies a non-halting sequences of configurations. If God
>>>>>>> himself said otherwise then God himself would be a liar.
>>>>>>>
>>>>>>
>>>>>> Except that if H/embedded_H aborts its simulation and goes to
>>>>>> H.Qn, then the CORRECT simulation of its input (that done by a
>>>>>> REAL UTM) will show that it will go to H^.Qn.
>>>>>>
>>>>>> All you have proven is that if H doesn't abort, and thus doesn't
>>>>>> go to H.Qn, and thus fails to be a correct decider, then H^
>>>>>> applied to <H^> is non-halting.
>>>>>>
>>>>>> You keep on thinking that a simulation that aborts its simulation
>>>>>> is a 'correct' simulation. By the definition in Computation
>>>>>> Theory, this is not true. If you think it is, it just proves that
>>>>>> you don't understand the field.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>> If we know that we have a black cat then we know that we have a cat.
>>>>>>
>>>>>> Except that if you DON'T have a black cat but think you do then
>>>>>> you are wrong. If H aborts its simulation, it isn't a UTM and
>>>>>> doesn't 'correctly' simulate.
>>>>>>
>>>>>>>
>>>>>>> If we know that we have a sequence of configurations that cannot
>>>>>>> possibly ever reach its final state then we know that we have a
>>>>>>> non-halting sequence of configurations.
>>>>>>>
>>>>>>
>>>>>> Except that is has been PROVEN that if H -> H.Qn then the pattern
>>>>>> WILL reach the final state.
>>>>>>
>>>>>> The fact that H can't ever reach that state proves just proves
>>>>>> that if H is a UTM, which don't abort, then H^ will be
>>>>>> non-halting, but H is still wrong for not answering. If H does
>>>>>> abort, then it hasn't proven anything, and it has been proven that
>>>>>> it is wrong.
>>>>>>
>>>>>> FAIL
>>>>>
>>>>> You are either not bright enough to get this or dishonest.
>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>
>>>>
>>>> So, can't refute what I say so you go to arguing by insults, classic
>>>> Olcott logical fallicy.
>>>>
>>>
>>> Fundamentally you seem to lack the intellectual capacity to
>>> understand what I am saying. This is proven on the basis that what I
>>> am saying can be verified as true entirely on the basis of the
>>> meaning of its words.
>>
>> Except that it has been shown that you keep on using the WRONG
>> definitions of the words.
>>
>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY
>> repoduces the behavior of its input (so if it is non-halting, so will
>> the UTM). Also you think that there can be a 'Correct Simulation' by
>> something that is NOT actully a UTM.
>>
>> Care to show anywhere where your misdefinitions are support in the
>> field fo Computation Theory.
>>
>> That just PROVES that you aren't actually working on the Halting
>> Problem of Computation Theory.
>>
>>>
>>>> Face it, you are just WRONG about your assertions, maybe because you
>>>> just don't know the field, so don't have any idea what is legal or not.
>>>>
>>>> Also note, you keep talking about needing 'Computer Scientists' to
>>>> understand, that is really incorrect, you need to be able to explain
>>>> it to someone who understands Computation Theory, which is a fairly
>>>> specialized branch of Mathematics. Yes, it is part of the foundation
>>>> of Computer Science, but isn't the sort of thing that a normal
>>>> Computer Scientist will deal with day to day.
>>>
>>> I need someone to analyze what I am saying on the deep meaning of
>>> what I am saying instead of mere rote memorized meanings from textbooks.
>>
>> No, you need to learn that words have PRECISE meanings, and you aren't
>> allowed to change them, no mwtter how much it 'makes sense' to do so.
>>
>>>
>>> The key mistake that my reviewers are making is that they believe
>>> that the halt decider is supposed to evaluate its input on the basis
>>> of some proxy for the actual behavior of this actual input rather
>>> than the actual behavior specified by this actual input.
>>>
>>
>>
>> Just proves you aren't working on the Halting Problem, as the
>> DEFINITION of the Halting problems says that it is, because you don't
>> actually understand the meaning of 'actual behavior'.
>>
>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w
>> halts, and to H,Qn if M applied to w will never halt.
>>
>
> If you are supposed to report when Bill arrives at your house and Sam
> arrives at you house and you really really believe that Sam's arrival is
> a valid proxy for Bill's arrival then when I ask you did Bill arrive at
> your house? you say "yes" even though correct the answer is "no".


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

<XqednSC0JrzZgJ7_nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 08 Feb 2022 19:47:48 -0600
Date: Tue, 8 Feb 2022 19:47: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.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<stv57t$1ist$3@gioia.aioe.org>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <stv57t$1ist$3@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <XqednSC0JrzZgJ7_nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 22
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XOedrK8GHQ2QaxFIRth+Gvk5axtL+SqPpUWLxqQAEVdHpCUFQjF0Bu67lPYrythchHgCkeSsFL8dyht!WGo/FqhCg2t3/Omdm4COk9ObmV5bnyhgA/18iqh+jrI5YuPuiOROZs5rCYqRbsKK3QzoSPjZZK3M
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: 2851
 by: olcott - Wed, 9 Feb 2022 01:47 UTC

On 2/8/2022 7:26 PM, Python wrote:
> olcott wrote:
> ...
>> Refuting the halting problem proofs is only a sideline of mine, my
>> actual goal is to mathematically formalize the notion of truth. This
>> establishes the anchor for Davidson's truth conditional semantics.
>
> You are starting the race with a dead horse.
>
>

If that was true then someone could point to a mistake.
My refutation of the halting problem proofs is isomorphic to Tarski's
undefinability theorem and Gödel's 1931 Incompleteness theorem, refuting
all three with essentially the same reasoning.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<Z9FMJ.20112$Y1A7.6113@fx43.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<stv57t$1ist$3@gioia.aioe.org>
<XqednSC0JrzZgJ7_nZ2dnUU7-UHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <XqednSC0JrzZgJ7_nZ2dnUU7-UHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 27
Message-ID: <Z9FMJ.20112$Y1A7.6113@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 8 Feb 2022 20:55:05 -0500
X-Received-Bytes: 2919
 by: Richard Damon - Wed, 9 Feb 2022 01:55 UTC

On 2/8/22 8:47 PM, olcott wrote:
> On 2/8/2022 7:26 PM, Python wrote:
>> olcott wrote:
>> ...
>>> Refuting the halting problem proofs is only a sideline of mine, my
>>> actual goal is to mathematically formalize the notion of truth. This
>>> establishes the anchor for Davidson's truth conditional semantics.
>>
>> You are starting the race with a dead horse.
>>
>>
>
> If that was true then someone could point to a mistake.
> My refutation of the halting problem proofs is isomorphic to Tarski's
> undefinability theorem and Gödel's 1931 Incompleteness theorem, refuting
> all three with essentially the same reasoning.
>

WE HAVE. YOu just ignore them because, I suppose, you just don't
understand enough to say anything reasonable about the refutations.

To say that NO ONE has pointed out a mistake is just a blantent LIE,
that shows how much you really value 'Truth'.

I think it is clear where your proof stands, and I really think you do
to, but refuse to accept it because it means admitting your life is a
abject failure.

Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]

<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 02:19:39 +0000
Date: Tue, 8 Feb 2022 20:19:50 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <AXEMJ.6305$4vG9.2509@fx19.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
Lines: 294
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZCvwFkta1U6Di1zk2qqttfwN/UqctbK22b6mL6u0VsiEaUJNau9yB6xXSPz7nswLduVBgCdIkoxQ0v5!t1Szjv46bkn1CTcs+ON+doOLH7HPQTywxZH43CcZQNRlFANl0CKk6WWNNIgw8XnN9tc29Ho6iqU5
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: 15817
 by: olcott - Wed, 9 Feb 2022 02:19 UTC

On 2/8/2022 7:39 PM, Richard Damon wrote:
> On 2/8/22 7:31 PM, olcott wrote:
>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>> On 2/8/22 10:35 AM, olcott wrote:
>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H
>>>>>>>>>>>>>>>>>>>>>> aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise H
>>>>>>>>>>>>>>>>>>>>>> transitions to its
>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the
>>>>>>>>>>>>>>>>>>>>> case where the
>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem is
>>>>>>>>>>>>>>>>>>>> undecidable. That is all that I need to refute these
>>>>>>>>>>>>>>>>>>>> proofs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set
>>>>>>>>>>>>>>>>>>>>> of patterns such
>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or matches
>>>>>>>>>>>>>>>>>>>>> one of these
>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show
>>>>>>>>>>>>>>>>>>>> that their counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to
>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to H.Qn, then by construction H^ <H^>
>>>>>>>>>>>>>>>>>>> goes to H^.Qn, and halts, and since H, to be an
>>>>>>>>>>>>>>>>>>> accurate Halt Decider, must only go to H,Qn if the
>>>>>>>>>>>>>>>>>>> machine its input represents will never halt. They
>>>>>>>>>>>>>>>>>>> you also don't seem to understand that the computaton
>>>>>>>>>>>>>>>>>>> that <H^> <H^> represents IS H^ applied to <H^>. So,
>>>>>>>>>>>>>>>>>>> H was just wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing
>>>>>>>>>>>>>>>>>>> pile of unsound logic based on wrong definitions that
>>>>>>>>>>>>>>>>>>> have hoodwinked yourself into thinking you have shown
>>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually understand
>>>>>>>>>>>>>>>>>>> what actual Truth is.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>>>>> understand that you are wrong and never will because
>>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation Theory to
>>>>>>>>>>>>>>>>> talk about it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders they
>>>>>>>>>>>>>>>>>> are only accountable for computing the mapping from
>>>>>>>>>>>>>>>>>> their input finite strings to an accept or reject
>>>>>>>>>>>>>>>>>> state on the basis of whether or not their correctly
>>>>>>>>>>>>>>>>>> simulated input could ever reach its final state: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM which
>>>>>>>>>>>>>>>>> BY DEFINITION exactly matches the behavior of
>>>>>>>>>>>>>>>>> Computation that it is representation of, which for
>>>>>>>>>>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps for
>>>>>>>>>>>>>>>> the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to
>>>>>>>>>>>>>>>> transition to ⟨Ĥ⟩.qn then the input to embedded_H meets
>>>>>>>>>>>>>>>> the Linz definition of a sequence of configurations that
>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its input
>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the same
>>>>>>>>>>>>>> three iterations:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of steps,
>>>>>>>>>>>>>> which proves that this input cannot possibly meet the Linz
>>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> OK, so the only computatiopn that you show that does not
>>>>>>>>>>>>> halt is H, so H can not be a decider.
>>>>>>>>>>>>
>>>>>>>>>>>> In the above example embedded_H simulates three iterations
>>>>>>>>>>>> of nested simulation to match the infinitely nested
>>>>>>>>>>>> simulation pattern.
>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is using
>>>>>>>>>>> it will Halt,
>>>>>>>>>>
>>>>>>>>>> embedded_H only examines the actual behavior of its inputs as
>>>>>>>>>> if its was a guard assigned to watch the front. If someone
>>>>>>>>>> comes in the back door (non-inputs) embedded_H is not even
>>>>>>>>>> allowed to pay attention.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>>> behavior of H^ applied to <H^> you are lying about doing the
>>>>>>>>> Halting Problem.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing in
>>>>>>>> the universe can possibly contradict the fact that the input
>>>>>>>> specifies a non-halting sequences of configurations. If God
>>>>>>>> himself said otherwise then God himself would be a liar.
>>>>>>>>
>>>>>>>
>>>>>>> Except that if H/embedded_H aborts its simulation and goes to
>>>>>>> H.Qn, then the CORRECT simulation of its input (that done by a
>>>>>>> REAL UTM) will show that it will go to H^.Qn.
>>>>>>>
>>>>>>> All you have proven is that if H doesn't abort, and thus doesn't
>>>>>>> go to H.Qn, and thus fails to be a correct decider, then H^
>>>>>>> applied to <H^> is non-halting.
>>>>>>>
>>>>>>> You keep on thinking that a simulation that aborts its simulation
>>>>>>> is a 'correct' simulation. By the definition in Computation
>>>>>>> Theory, this is not true. If you think it is, it just proves that
>>>>>>> you don't understand the field.
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>>> If we know that we have a black cat then we know that we have a
>>>>>>>> cat.
>>>>>>>
>>>>>>> Except that if you DON'T have a black cat but think you do then
>>>>>>> you are wrong. If H aborts its simulation, it isn't a UTM and
>>>>>>> doesn't 'correctly' simulate.
>>>>>>>
>>>>>>>>
>>>>>>>> If we know that we have a sequence of configurations that cannot
>>>>>>>> possibly ever reach its final state then we know that we have a
>>>>>>>> non-halting sequence of configurations.
>>>>>>>>
>>>>>>>
>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the pattern
>>>>>>> WILL reach the final state.
>>>>>>>
>>>>>>> The fact that H can't ever reach that state proves just proves
>>>>>>> that if H is a UTM, which don't abort, then H^ will be
>>>>>>> non-halting, but H is still wrong for not answering. If H does
>>>>>>> abort, then it hasn't proven anything, and it has been proven
>>>>>>> that it is wrong.
>>>>>>>
>>>>>>> FAIL
>>>>>>
>>>>>> You are either not bright enough to get this or dishonest.
>>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>>
>>>>>
>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>> classic Olcott logical fallicy.
>>>>>
>>>>
>>>> Fundamentally you seem to lack the intellectual capacity to
>>>> understand what I am saying. This is proven on the basis that what I
>>>> am saying can be verified as true entirely on the basis of the
>>>> meaning of its words.
>>>
>>> Except that it has been shown that you keep on using the WRONG
>>> definitions of the words.
>>>
>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY
>>> repoduces the behavior of its input (so if it is non-halting, so will
>>> the UTM). Also you think that there can be a 'Correct Simulation' by
>>> something that is NOT actully a UTM.
>>>
>>> Care to show anywhere where your misdefinitions are support in the
>>> field fo Computation Theory.
>>>
>>> That just PROVES that you aren't actually working on the Halting
>>> Problem of Computation Theory.
>>>
>>>>
>>>>> Face it, you are just WRONG about your assertions, maybe because
>>>>> you just don't know the field, so don't have any idea what is legal
>>>>> or not.
>>>>>
>>>>> Also note, you keep talking about needing 'Computer Scientists' to
>>>>> understand, that is really incorrect, you need to be able to
>>>>> explain it to someone who understands Computation Theory, which is
>>>>> a fairly specialized branch of Mathematics. Yes, it is part of the
>>>>> foundation of Computer Science, but isn't the sort of thing that a
>>>>> normal Computer Scientist will deal with day to day.
>>>>
>>>> I need someone to analyze what I am saying on the deep meaning of
>>>> what I am saying instead of mere rote memorized meanings from
>>>> textbooks.
>>>
>>> No, you need to learn that words have PRECISE meanings, and you
>>> aren't allowed to change them, no mwtter how much it 'makes sense' to
>>> do so.
>>>
>>>>
>>>> The key mistake that my reviewers are making is that they believe
>>>> that the halt decider is supposed to evaluate its input on the basis
>>>> of some proxy for the actual behavior of this actual input rather
>>>> than the actual behavior specified by this actual input.
>>>>
>>>
>>>
>>> Just proves you aren't working on the Halting Problem, as the
>>> DEFINITION of the Halting problems says that it is, because you don't
>>> actually understand the meaning of 'actual behavior'.
>>>
>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w
>>> halts, and to H,Qn if M applied to w will never halt.
>>>
>>
>> If you are supposed to report when Bill arrives at your house and Sam
>> arrives at you house and you really really believe that Sam's arrival
>> is a valid proxy for Bill's arrival then when I ask you did Bill
>> arrive at your house? you say "yes" even though correct the answer is
>> "no".
>
> You really like to make you Herrings Red, don't you.
>
> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w is
> based on the behavior of M applied to w.
>
> YOU are the one making the wrong report.


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

<udOMJ.5581$0vE9.5549@fx17.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx17.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 314
Message-ID: <udOMJ.5581$0vE9.5549@fx17.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 07:13:14 -0500
X-Received-Bytes: 16937
 by: Richard Damon - Wed, 9 Feb 2022 12:13 UTC

On 2/8/22 9:19 PM, olcott wrote:
> On 2/8/2022 7:39 PM, Richard Damon wrote:
>> On 2/8/22 7:31 PM, olcott wrote:
>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H
>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise
>>>>>>>>>>>>>>>>>>>>>>> H transitions to its
>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the
>>>>>>>>>>>>>>>>>>>>>> case where the
>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem is
>>>>>>>>>>>>>>>>>>>>> undecidable. That is all that I need to refute
>>>>>>>>>>>>>>>>>>>>> these proofs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite set
>>>>>>>>>>>>>>>>>>>>>> of patterns such
>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or matches
>>>>>>>>>>>>>>>>>>>>>> one of these
>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be all
>>>>>>>>>>>>>>>>>>>>> knowing. To refute the proofs I merely need to show
>>>>>>>>>>>>>>>>>>>>> that their counter-example can be proved to never
>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to
>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to H.Qn, then by construction H^ <H^>
>>>>>>>>>>>>>>>>>>>> goes to H^.Qn, and halts, and since H, to be an
>>>>>>>>>>>>>>>>>>>> accurate Halt Decider, must only go to H,Qn if the
>>>>>>>>>>>>>>>>>>>> machine its input represents will never halt. They
>>>>>>>>>>>>>>>>>>>> you also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied
>>>>>>>>>>>>>>>>>>>> to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing
>>>>>>>>>>>>>>>>>>>> pile of unsound logic based on wrong definitions
>>>>>>>>>>>>>>>>>>>> that have hoodwinked yourself into thinking you have
>>>>>>>>>>>>>>>>>>>> shown something useful.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually understand
>>>>>>>>>>>>>>>>>>>> what actual Truth is.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>>>>>> understand that you are wrong and never will because
>>>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation Theory
>>>>>>>>>>>>>>>>>> to talk about it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders
>>>>>>>>>>>>>>>>>>> they are only accountable for computing the mapping
>>>>>>>>>>>>>>>>>>> from their input finite strings to an accept or
>>>>>>>>>>>>>>>>>>> reject state on the basis of whether or not their
>>>>>>>>>>>>>>>>>>> correctly simulated input could ever reach its final
>>>>>>>>>>>>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM which
>>>>>>>>>>>>>>>>>> BY DEFINITION exactly matches the behavior of
>>>>>>>>>>>>>>>>>> Computation that it is representation of, which for
>>>>>>>>>>>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps for
>>>>>>>>>>>>>>>>> the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to
>>>>>>>>>>>>>>>>> transition to ⟨Ĥ⟩.qn then the input to embedded_H meets
>>>>>>>>>>>>>>>>> the Linz definition of a sequence of configurations
>>>>>>>>>>>>>>>>> that never halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its input
>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the same
>>>>>>>>>>>>>>> three iterations:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly meet
>>>>>>>>>>>>>>> the Linz definition of halting:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does not
>>>>>>>>>>>>>> halt is H, so H can not be a decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> In the above example embedded_H simulates three iterations
>>>>>>>>>>>>> of nested simulation to match the infinitely nested
>>>>>>>>>>>>> simulation pattern.
>>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is
>>>>>>>>>>>> using it will Halt,
>>>>>>>>>>>
>>>>>>>>>>> embedded_H only examines the actual behavior of its inputs as
>>>>>>>>>>> if its was a guard assigned to watch the front. If someone
>>>>>>>>>>> comes in the back door (non-inputs) embedded_H is not even
>>>>>>>>>>> allowed to pay attention.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>>>> behavior of H^ applied to <H^> you are lying about doing the
>>>>>>>>>> Halting Problem.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing in
>>>>>>>>> the universe can possibly contradict the fact that the input
>>>>>>>>> specifies a non-halting sequences of configurations. If God
>>>>>>>>> himself said otherwise then God himself would be a liar.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that if H/embedded_H aborts its simulation and goes to
>>>>>>>> H.Qn, then the CORRECT simulation of its input (that done by a
>>>>>>>> REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>
>>>>>>>> All you have proven is that if H doesn't abort, and thus doesn't
>>>>>>>> go to H.Qn, and thus fails to be a correct decider, then H^
>>>>>>>> applied to <H^> is non-halting.
>>>>>>>>
>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>> Computation Theory, this is not true. If you think it is, it
>>>>>>>> just proves that you don't understand the field.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>>> If we know that we have a black cat then we know that we have a
>>>>>>>>> cat.
>>>>>>>>
>>>>>>>> Except that if you DON'T have a black cat but think you do then
>>>>>>>> you are wrong. If H aborts its simulation, it isn't a UTM and
>>>>>>>> doesn't 'correctly' simulate.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>> cannot possibly ever reach its final state then we know that we
>>>>>>>>> have a non-halting sequence of configurations.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>> pattern WILL reach the final state.
>>>>>>>>
>>>>>>>> The fact that H can't ever reach that state proves just proves
>>>>>>>> that if H is a UTM, which don't abort, then H^ will be
>>>>>>>> non-halting, but H is still wrong for not answering. If H does
>>>>>>>> abort, then it hasn't proven anything, and it has been proven
>>>>>>>> that it is wrong.
>>>>>>>>
>>>>>>>> FAIL
>>>>>>>
>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>>>
>>>>>>
>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>> classic Olcott logical fallicy.
>>>>>>
>>>>>
>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>> understand what I am saying. This is proven on the basis that what
>>>>> I am saying can be verified as true entirely on the basis of the
>>>>> meaning of its words.
>>>>
>>>> Except that it has been shown that you keep on using the WRONG
>>>> definitions of the words.
>>>>
>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM EXACTLY
>>>> repoduces the behavior of its input (so if it is non-halting, so
>>>> will the UTM). Also you think that there can be a 'Correct
>>>> Simulation' by something that is NOT actully a UTM.
>>>>
>>>> Care to show anywhere where your misdefinitions are support in the
>>>> field fo Computation Theory.
>>>>
>>>> That just PROVES that you aren't actually working on the Halting
>>>> Problem of Computation Theory.
>>>>
>>>>>
>>>>>> Face it, you are just WRONG about your assertions, maybe because
>>>>>> you just don't know the field, so don't have any idea what is
>>>>>> legal or not.
>>>>>>
>>>>>> Also note, you keep talking about needing 'Computer Scientists' to
>>>>>> understand, that is really incorrect, you need to be able to
>>>>>> explain it to someone who understands Computation Theory, which is
>>>>>> a fairly specialized branch of Mathematics. Yes, it is part of the
>>>>>> foundation of Computer Science, but isn't the sort of thing that a
>>>>>> normal Computer Scientist will deal with day to day.
>>>>>
>>>>> I need someone to analyze what I am saying on the deep meaning of
>>>>> what I am saying instead of mere rote memorized meanings from
>>>>> textbooks.
>>>>
>>>> No, you need to learn that words have PRECISE meanings, and you
>>>> aren't allowed to change them, no mwtter how much it 'makes sense'
>>>> to do so.
>>>>
>>>>>
>>>>> The key mistake that my reviewers are making is that they believe
>>>>> that the halt decider is supposed to evaluate its input on the
>>>>> basis of some proxy for the actual behavior of this actual input
>>>>> rather than the actual behavior specified by this actual input.
>>>>>
>>>>
>>>>
>>>> Just proves you aren't working on the Halting Problem, as the
>>>> DEFINITION of the Halting problems says that it is, because you
>>>> don't actually understand the meaning of 'actual behavior'.
>>>>
>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w
>>>> halts, and to H,Qn if M applied to w will never halt.
>>>>
>>>
>>> If you are supposed to report when Bill arrives at your house and Sam
>>> arrives at you house and you really really believe that Sam's arrival
>>> is a valid proxy for Bill's arrival then when I ask you did Bill
>>> arrive at your house? you say "yes" even though correct the answer is
>>> "no".
>>
>> You really like to make you Herrings Red, don't you.
>>
>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w is
>> based on the behavior of M applied to w.
>>
>> YOU are the one making the wrong report.
>
> When anyone in the universe defines something besides the actual
> behavior specified by the input to embedded_H as the only correct halt
> status criterion measure that might as well say that cats are not animals.
>
>


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

<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 07:13:13 -0600
Date: Wed, 9 Feb 2022 07:13:12 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <udOMJ.5581$0vE9.5549@fx17.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
Lines: 344
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6WKZRoYeHRCDvnVAAOsErxgLDmiwGyQXlfm+dxYcV2Gf7besYiO1tuFDA1+PPX0xNwpvWlQDdaNofyt!LqxQJeHg6Ho5VNKikPlsG+iHXxIsIJaK9i5gJ7cryPJ2+ObtjZ8iWAf+oGUR0K5a1j4K4+B+/hN6
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: 18808
 by: olcott - Wed, 9 Feb 2022 13:13 UTC

On 2/9/2022 6:13 AM, Richard Damon wrote:
> On 2/8/22 9:19 PM, olcott wrote:
>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>> On 2/8/22 7:31 PM, olcott wrote:
>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H
>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state. Otherwise
>>>>>>>>>>>>>>>>>>>>>>>> H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the
>>>>>>>>>>>>>>>>>>>>>>> case where the
>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem is
>>>>>>>>>>>>>>>>>>>>>> undecidable. That is all that I need to refute
>>>>>>>>>>>>>>>>>>>>>> these proofs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite
>>>>>>>>>>>>>>>>>>>>>>> set of patterns such
>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or matches
>>>>>>>>>>>>>>>>>>>>>>> one of these
>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be
>>>>>>>>>>>>>>>>>>>>>> all knowing. To refute the proofs I merely need to
>>>>>>>>>>>>>>>>>>>>>> show that their counter-example can be proved to
>>>>>>>>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to
>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to H.Qn, then by construction H^
>>>>>>>>>>>>>>>>>>>>> <H^> goes to H^.Qn, and halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider, must only go to H,Qn if
>>>>>>>>>>>>>>>>>>>>> the machine its input represents will never halt.
>>>>>>>>>>>>>>>>>>>>> They you also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied
>>>>>>>>>>>>>>>>>>>>> to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you claim
>>>>>>>>>>>>>>>>>>>>> youhave, but only that you have amassed an amazing
>>>>>>>>>>>>>>>>>>>>> pile of unsound logic based on wrong definitions
>>>>>>>>>>>>>>>>>>>>> that have hoodwinked yourself into thinking you
>>>>>>>>>>>>>>>>>>>>> have shown something useful.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>>>>>>> understand that you are wrong and never will because
>>>>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation Theory
>>>>>>>>>>>>>>>>>>> to talk about it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders
>>>>>>>>>>>>>>>>>>>> they are only accountable for computing the mapping
>>>>>>>>>>>>>>>>>>>> from their input finite strings to an accept or
>>>>>>>>>>>>>>>>>>>> reject state on the basis of whether or not their
>>>>>>>>>>>>>>>>>>>> correctly simulated input could ever reach its final
>>>>>>>>>>>>>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM which
>>>>>>>>>>>>>>>>>>> BY DEFINITION exactly matches the behavior of
>>>>>>>>>>>>>>>>>>> Computation that it is representation of, which for
>>>>>>>>>>>>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps for
>>>>>>>>>>>>>>>>>> the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to
>>>>>>>>>>>>>>>>>> transition to ⟨Ĥ⟩.qn then the input to embedded_H
>>>>>>>>>>>>>>>>>> meets the Linz definition of a sequence of
>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its input
>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the
>>>>>>>>>>>>>>>> same three iterations:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly meet
>>>>>>>>>>>>>>>> the Linz definition of halting:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does not
>>>>>>>>>>>>>>> halt is H, so H can not be a decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In the above example embedded_H simulates three iterations
>>>>>>>>>>>>>> of nested simulation to match the infinitely nested
>>>>>>>>>>>>>> simulation pattern.
>>>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is
>>>>>>>>>>>>> using it will Halt,
>>>>>>>>>>>>
>>>>>>>>>>>> embedded_H only examines the actual behavior of its inputs
>>>>>>>>>>>> as if its was a guard assigned to watch the front. If
>>>>>>>>>>>> someone comes in the back door (non-inputs) embedded_H is
>>>>>>>>>>>> not even allowed to pay attention.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>>>>> behavior of H^ applied to <H^> you are lying about doing the
>>>>>>>>>>> Halting Problem.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing in
>>>>>>>>>> the universe can possibly contradict the fact that the input
>>>>>>>>>> specifies a non-halting sequences of configurations. If God
>>>>>>>>>> himself said otherwise then God himself would be a liar.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that if H/embedded_H aborts its simulation and goes to
>>>>>>>>> H.Qn, then the CORRECT simulation of its input (that done by a
>>>>>>>>> REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>>
>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct decider,
>>>>>>>>> then H^ applied to <H^> is non-halting.
>>>>>>>>>
>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>>> Computation Theory, this is not true. If you think it is, it
>>>>>>>>> just proves that you don't understand the field.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>>> If we know that we have a black cat then we know that we have
>>>>>>>>>> a cat.
>>>>>>>>>
>>>>>>>>> Except that if you DON'T have a black cat but think you do then
>>>>>>>>> you are wrong. If H aborts its simulation, it isn't a UTM and
>>>>>>>>> doesn't 'correctly' simulate.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>>> cannot possibly ever reach its final state then we know that
>>>>>>>>>> we have a non-halting sequence of configurations.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>
>>>>>>>>> The fact that H can't ever reach that state proves just proves
>>>>>>>>> that if H is a UTM, which don't abort, then H^ will be
>>>>>>>>> non-halting, but H is still wrong for not answering. If H does
>>>>>>>>> abort, then it hasn't proven anything, and it has been proven
>>>>>>>>> that it is wrong.
>>>>>>>>>
>>>>>>>>> FAIL
>>>>>>>>
>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>>>>
>>>>>>>
>>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>>> classic Olcott logical fallicy.
>>>>>>>
>>>>>>
>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>> understand what I am saying. This is proven on the basis that what
>>>>>> I am saying can be verified as true entirely on the basis of the
>>>>>> meaning of its words.
>>>>>
>>>>> Except that it has been shown that you keep on using the WRONG
>>>>> definitions of the words.
>>>>>
>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>> non-halting, so will the UTM). Also you think that there can be a
>>>>> 'Correct Simulation' by something that is NOT actully a UTM.
>>>>>
>>>>> Care to show anywhere where your misdefinitions are support in the
>>>>> field fo Computation Theory.
>>>>>
>>>>> That just PROVES that you aren't actually working on the Halting
>>>>> Problem of Computation Theory.
>>>>>
>>>>>>
>>>>>>> Face it, you are just WRONG about your assertions, maybe because
>>>>>>> you just don't know the field, so don't have any idea what is
>>>>>>> legal or not.
>>>>>>>
>>>>>>> Also note, you keep talking about needing 'Computer Scientists'
>>>>>>> to understand, that is really incorrect, you need to be able to
>>>>>>> explain it to someone who understands Computation Theory, which
>>>>>>> is a fairly specialized branch of Mathematics. Yes, it is part of
>>>>>>> the foundation of Computer Science, but isn't the sort of thing
>>>>>>> that a normal Computer Scientist will deal with day to day.
>>>>>>
>>>>>> I need someone to analyze what I am saying on the deep meaning of
>>>>>> what I am saying instead of mere rote memorized meanings from
>>>>>> textbooks.
>>>>>
>>>>> No, you need to learn that words have PRECISE meanings, and you
>>>>> aren't allowed to change them, no mwtter how much it 'makes sense'
>>>>> to do so.
>>>>>
>>>>>>
>>>>>> The key mistake that my reviewers are making is that they believe
>>>>>> that the halt decider is supposed to evaluate its input on the
>>>>>> basis of some proxy for the actual behavior of this actual input
>>>>>> rather than the actual behavior specified by this actual input.
>>>>>>
>>>>>
>>>>>
>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>> DEFINITION of the Halting problems says that it is, because you
>>>>> don't actually understand the meaning of 'actual behavior'.
>>>>>
>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied to w
>>>>> halts, and to H,Qn if M applied to w will never halt.
>>>>>
>>>>
>>>> If you are supposed to report when Bill arrives at your house and
>>>> Sam arrives at you house and you really really believe that Sam's
>>>> arrival is a valid proxy for Bill's arrival then when I ask you did
>>>> Bill arrive at your house? you say "yes" even though correct the
>>>> answer is "no".
>>>
>>> You really like to make you Herrings Red, don't you.
>>>
>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w
>>> is based on the behavior of M applied to w.
>>>
>>> YOU are the one making the wrong report.
>>
>> When anyone in the universe defines something besides the actual
>> behavior specified by the input to embedded_H as the only correct halt
>> status criterion measure that might as well say that cats are not
>> animals.
>>
>>
>
> Just shows your problem in comprehension, doesn't it. You just refuse to
> accept the definition because it doesn't match your idea of what you need.
>
> Note, 'The Actual Behavior specifeid by the input' IS precisly defined,
> and it IS the behavior that the input specifes, The input to the decider
> is the description of a computation, and the actual behavior sepecified
> by the input is by defintion the behavior of that computation that the
> input describes.
>
> YOU are the one that wants to change it to not be the behavior specified
> by the input, but the behavior of the program that is processing the
> input. YOUR definition of the behavior has the problem that the behavior
> is no longer just specified by 'the input' but is also a function of
> what program you give that input to.
>
> Your logic is just not sound, and sometimes I wonder how sound your mind
> is.
>
> This statement of your just shows how you have lost touch with the
> reality of the situation. You seem to think the Univese must be wrong
> because it doesn't match your expectations. THAT is a sign of mental
> illness.
>
> FAIL.


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

<4mPMJ.19776$iK66.4863@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!news2.arglkargh.de!news.karotte.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 386
Message-ID: <4mPMJ.19776$iK66.4863@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 08:30:40 -0500
X-Received-Bytes: 20284
 by: Richard Damon - Wed, 9 Feb 2022 13:30 UTC

On 2/9/22 8:13 AM, olcott wrote:
> On 2/9/2022 6:13 AM, Richard Damon wrote:
>> On 2/8/22 9:19 PM, olcott wrote:
>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM UTC-8,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of matching
>>>>>>>>>>>>>>>>>>>>>>>>> infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H
>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover the
>>>>>>>>>>>>>>>>>>>>>>>> case where the
>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem
>>>>>>>>>>>>>>>>>>>>>>> is undecidable. That is all that I need to refute
>>>>>>>>>>>>>>>>>>>>>>> these proofs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite
>>>>>>>>>>>>>>>>>>>>>>>> set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be
>>>>>>>>>>>>>>>>>>>>>>> all knowing. To refute the proofs I merely need
>>>>>>>>>>>>>>>>>>>>>>> to show that their counter-example can be proved
>>>>>>>>>>>>>>>>>>>>>>> to never halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to
>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to H.Qn, then by construction H^
>>>>>>>>>>>>>>>>>>>>>> <H^> goes to H^.Qn, and halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider, must only go to H,Qn if
>>>>>>>>>>>>>>>>>>>>>> the machine its input represents will never halt.
>>>>>>>>>>>>>>>>>>>>>> They you also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^ applied
>>>>>>>>>>>>>>>>>>>>>> to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you
>>>>>>>>>>>>>>>>>>>>>> claim youhave, but only that you have amassed an
>>>>>>>>>>>>>>>>>>>>>> amazing pile of unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked yourself into
>>>>>>>>>>>>>>>>>>>>>> thinking you have shown something useful.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>>>>>>>> understand that you are wrong and never will
>>>>>>>>>>>>>>>>>>>>> because you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation Theory
>>>>>>>>>>>>>>>>>>>> to talk about it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders
>>>>>>>>>>>>>>>>>>>>> they are only accountable for computing the mapping
>>>>>>>>>>>>>>>>>>>>> from their input finite strings to an accept or
>>>>>>>>>>>>>>>>>>>>> reject state on the basis of whether or not their
>>>>>>>>>>>>>>>>>>>>> correctly simulated input could ever reach its
>>>>>>>>>>>>>>>>>>>>> final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the behavior of
>>>>>>>>>>>>>>>>>>>> Computation that it is representation of, which for
>>>>>>>>>>>>>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps
>>>>>>>>>>>>>>>>>>> for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>> to transition to ⟨Ĥ⟩.qn then the input to embedded_H
>>>>>>>>>>>>>>>>>>> meets the Linz definition of a sequence of
>>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its input
>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the
>>>>>>>>>>>>>>>>> same three iterations:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly
>>>>>>>>>>>>>>>>> meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does not
>>>>>>>>>>>>>>>> halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>> iterations of nested simulation to match the infinitely
>>>>>>>>>>>>>>> nested simulation pattern.
>>>>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is
>>>>>>>>>>>>>> using it will Halt,
>>>>>>>>>>>>>
>>>>>>>>>>>>> embedded_H only examines the actual behavior of its inputs
>>>>>>>>>>>>> as if its was a guard assigned to watch the front. If
>>>>>>>>>>>>> someone comes in the back door (non-inputs) embedded_H is
>>>>>>>>>>>>> not even allowed to pay attention.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>>>>>> behavior of H^ applied to <H^> you are lying about doing the
>>>>>>>>>>>> Halting Problem.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing
>>>>>>>>>>> in the universe can possibly contradict the fact that the
>>>>>>>>>>> input specifies a non-halting sequences of configurations. If
>>>>>>>>>>> God himself said otherwise then God himself would be a liar.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except that if H/embedded_H aborts its simulation and goes to
>>>>>>>>>> H.Qn, then the CORRECT simulation of its input (that done by a
>>>>>>>>>> REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>>>
>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct decider,
>>>>>>>>>> then H^ applied to <H^> is non-halting.
>>>>>>>>>>
>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>>>> Computation Theory, this is not true. If you think it is, it
>>>>>>>>>> just proves that you don't understand the field.
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>>> If we know that we have a black cat then we know that we have
>>>>>>>>>>> a cat.
>>>>>>>>>>
>>>>>>>>>> Except that if you DON'T have a black cat but think you do
>>>>>>>>>> then you are wrong. If H aborts its simulation, it isn't a UTM
>>>>>>>>>> and doesn't 'correctly' simulate.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>>>> cannot possibly ever reach its final state then we know that
>>>>>>>>>>> we have a non-halting sequence of configurations.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>>
>>>>>>>>>> The fact that H can't ever reach that state proves just proves
>>>>>>>>>> that if H is a UTM, which don't abort, then H^ will be
>>>>>>>>>> non-halting, but H is still wrong for not answering. If H does
>>>>>>>>>> abort, then it hasn't proven anything, and it has been proven
>>>>>>>>>> that it is wrong.
>>>>>>>>>>
>>>>>>>>>> FAIL
>>>>>>>>>
>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>>>> classic Olcott logical fallicy.
>>>>>>>>
>>>>>>>
>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>> understand what I am saying. This is proven on the basis that
>>>>>>> what I am saying can be verified as true entirely on the basis of
>>>>>>> the meaning of its words.
>>>>>>
>>>>>> Except that it has been shown that you keep on using the WRONG
>>>>>> definitions of the words.
>>>>>>
>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>> non-halting, so will the UTM). Also you think that there can be a
>>>>>> 'Correct Simulation' by something that is NOT actully a UTM.
>>>>>>
>>>>>> Care to show anywhere where your misdefinitions are support in the
>>>>>> field fo Computation Theory.
>>>>>>
>>>>>> That just PROVES that you aren't actually working on the Halting
>>>>>> Problem of Computation Theory.
>>>>>>
>>>>>>>
>>>>>>>> Face it, you are just WRONG about your assertions, maybe because
>>>>>>>> you just don't know the field, so don't have any idea what is
>>>>>>>> legal or not.
>>>>>>>>
>>>>>>>> Also note, you keep talking about needing 'Computer Scientists'
>>>>>>>> to understand, that is really incorrect, you need to be able to
>>>>>>>> explain it to someone who understands Computation Theory, which
>>>>>>>> is a fairly specialized branch of Mathematics. Yes, it is part
>>>>>>>> of the foundation of Computer Science, but isn't the sort of
>>>>>>>> thing that a normal Computer Scientist will deal with day to day.
>>>>>>>
>>>>>>> I need someone to analyze what I am saying on the deep meaning of
>>>>>>> what I am saying instead of mere rote memorized meanings from
>>>>>>> textbooks.
>>>>>>
>>>>>> No, you need to learn that words have PRECISE meanings, and you
>>>>>> aren't allowed to change them, no mwtter how much it 'makes sense'
>>>>>> to do so.
>>>>>>
>>>>>>>
>>>>>>> The key mistake that my reviewers are making is that they believe
>>>>>>> that the halt decider is supposed to evaluate its input on the
>>>>>>> basis of some proxy for the actual behavior of this actual input
>>>>>>> rather than the actual behavior specified by this actual input.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>>> DEFINITION of the Halting problems says that it is, because you
>>>>>> don't actually understand the meaning of 'actual behavior'.
>>>>>>
>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied to
>>>>>> w halts, and to H,Qn if M applied to w will never halt.
>>>>>>
>>>>>
>>>>> If you are supposed to report when Bill arrives at your house and
>>>>> Sam arrives at you house and you really really believe that Sam's
>>>>> arrival is a valid proxy for Bill's arrival then when I ask you did
>>>>> Bill arrive at your house? you say "yes" even though correct the
>>>>> answer is "no".
>>>>
>>>> You really like to make you Herrings Red, don't you.
>>>>
>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w
>>>> is based on the behavior of M applied to w.
>>>>
>>>> YOU are the one making the wrong report.
>>>
>>> When anyone in the universe defines something besides the actual
>>> behavior specified by the input to embedded_H as the only correct
>>> halt status criterion measure that might as well say that cats are
>>> not animals.
>>>
>>>
>>
>> Just shows your problem in comprehension, doesn't it. You just refuse
>> to accept the definition because it doesn't match your idea of what
>> you need.
>>
>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>> defined, and it IS the behavior that the input specifes, The input to
>> the decider is the description of a computation, and the actual
>> behavior sepecified by the input is by defintion the behavior of that
>> computation that the input describes.
>>
>> YOU are the one that wants to change it to not be the behavior
>> specified by the input, but the behavior of the program that is
>> processing the input. YOUR definition of the behavior has the problem
>> that the behavior is no longer just specified by 'the input' but is
>> also a function of what program you give that input to.
>>
>> Your logic is just not sound, and sometimes I wonder how sound your
>> mind is.
>>
>> This statement of your just shows how you have lost touch with the
>> reality of the situation. You seem to think the Univese must be wrong
>> because it doesn't match your expectations. THAT is a sign of mental
>> illness.
>>
>> FAIL.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will never
Halt.


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

<93be378a-a8fd-42fa-b805-bf9925d24cacn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:622a:c6:: with SMTP id p6mr1468411qtw.191.1644417342008;
Wed, 09 Feb 2022 06:35:42 -0800 (PST)
X-Received: by 2002:a25:6f08:: with SMTP id k8mr2160786ybc.469.1644417341793;
Wed, 09 Feb 2022 06:35:41 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 9 Feb 2022 06:35:41 -0800 (PST)
In-Reply-To: <stv57t$1ist$3@gioia.aioe.org>
Injection-Info: google-groups.googlegroups.com; posting-host=96.253.108.61; posting-account=X_pe-goAAACrVTtZeoCLt7hslVPY2-Uo
NNTP-Posting-Host: 96.253.108.61
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<d2e2dce7-ea3a-4892-8076-44c2038b394bn@googlegroups.com> <stpa86$hib$1@dont-email.me>
<UgWLJ.9101$GjY3.7596@fx01.iad> <o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad> <2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad> <suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad> <xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad> <SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad> <EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad> <NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<stv57t$1ist$3@gioia.aioe.org>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <93be378a-a8fd-42fa-b805-bf9925d24cacn@googlegroups.com>
Subject: Re: Concise refutation of halting problem proofs V62 [ Linz Proof ]
From: xlt....@gmail.com (B.H.)
Injection-Date: Wed, 09 Feb 2022 14:35:42 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 12
 by: B.H. - Wed, 9 Feb 2022 14:35 UTC

On Tuesday, February 8, 2022 at 8:26:24 PM UTC-5, Python wrote:
> olcott wrote:
> ...
> > Refuting the halting problem proofs is only a sideline of mine, my
> > actual goal is to mathematically formalize the notion of truth. This
> > establishes the anchor for Davidson's truth conditional semantics.
> You are starting the race with a dead horse.

Do you mean the BND? Dead horse or not, I wonder if they know what exactly happened to my WW2-era-military veteran grandmother whom I believe to have been murdered by spies.

It probably is related to Karin Strenz etc., you get a return on your investment with a plus or minus sign in particular in international politics and military-type innovation these days.

-Philip

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

<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 10:31:06 -0600
Date: Wed, 9 Feb 2022 10:31:05 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<stpa86$hib$1@dont-email.me> <UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <4mPMJ.19776$iK66.4863@fx46.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
Lines: 362
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-EWQIq2lEGEB/JOjsDWret22ln/2KI4LnJmw3f9C7SM8pU6G7RVRfEKlzqNC4Vzx6UosA3d0SWpMwbB/!WvCAVUngaA5KGMDQNdFNYB1r9BLRf2gvvEeIiijUdfHKv1GrORuISM/f6oe4JrRYBIMfFcltI9TR
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: 20181
 by: olcott - Wed, 9 Feb 2022 16:31 UTC

On 2/9/2022 7:30 AM, Richard Damon wrote:
>
> On 2/9/22 8:13 AM, olcott wrote:
>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>> On 2/8/22 9:19 PM, olcott wrote:
>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched H
>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover
>>>>>>>>>>>>>>>>>>>>>>>>> the case where the
>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem
>>>>>>>>>>>>>>>>>>>>>>>> is undecidable. That is all that I need to
>>>>>>>>>>>>>>>>>>>>>>>> refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite
>>>>>>>>>>>>>>>>>>>>>>>>> set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be
>>>>>>>>>>>>>>>>>>>>>>>> all knowing. To refute the proofs I merely need
>>>>>>>>>>>>>>>>>>>>>>>> to show that their counter-example can be proved
>>>>>>>>>>>>>>>>>>>>>>>> to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied to
>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to H.Qn, then by construction H^
>>>>>>>>>>>>>>>>>>>>>>> <H^> goes to H^.Qn, and halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider, must only go to H,Qn if
>>>>>>>>>>>>>>>>>>>>>>> the machine its input represents will never halt.
>>>>>>>>>>>>>>>>>>>>>>> They you also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^
>>>>>>>>>>>>>>>>>>>>>>> applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you
>>>>>>>>>>>>>>>>>>>>>>> claim youhave, but only that you have amassed an
>>>>>>>>>>>>>>>>>>>>>>> amazing pile of unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked yourself into
>>>>>>>>>>>>>>>>>>>>>>> thinking you have shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science to
>>>>>>>>>>>>>>>>>>>>>> understand that you are wrong and never will
>>>>>>>>>>>>>>>>>>>>>> because you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders
>>>>>>>>>>>>>>>>>>>>>> they are only accountable for computing the
>>>>>>>>>>>>>>>>>>>>>> mapping from their input finite strings to an
>>>>>>>>>>>>>>>>>>>>>> accept or reject state on the basis of whether or
>>>>>>>>>>>>>>>>>>>>>> not their correctly simulated input could ever
>>>>>>>>>>>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the behavior of
>>>>>>>>>>>>>>>>>>>>> Computation that it is representation of, which for
>>>>>>>>>>>>>>>>>>>>> <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps
>>>>>>>>>>>>>>>>>>>> for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>>> to transition to ⟨Ĥ⟩.qn then the input to embedded_H
>>>>>>>>>>>>>>>>>>>> meets the Linz definition of a sequence of
>>>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its input
>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the
>>>>>>>>>>>>>>>>>> same three iterations:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly
>>>>>>>>>>>>>>>>>> meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does
>>>>>>>>>>>>>>>>> not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>> iterations of nested simulation to match the infinitely
>>>>>>>>>>>>>>>> nested simulation pattern.
>>>>>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is
>>>>>>>>>>>>>>> using it will Halt,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its inputs
>>>>>>>>>>>>>> as if its was a guard assigned to watch the front. If
>>>>>>>>>>>>>> someone comes in the back door (non-inputs) embedded_H is
>>>>>>>>>>>>>> not even allowed to pay attention.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>>>>>>> behavior of H^ applied to <H^> you are lying about doing
>>>>>>>>>>>>> the Halting Problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing
>>>>>>>>>>>> in the universe can possibly contradict the fact that the
>>>>>>>>>>>> input specifies a non-halting sequences of configurations.
>>>>>>>>>>>> If God himself said otherwise then God himself would be a liar.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and goes to
>>>>>>>>>>> H.Qn, then the CORRECT simulation of its input (that done by
>>>>>>>>>>> a REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>>>>
>>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct decider,
>>>>>>>>>>> then H^ applied to <H^> is non-halting.
>>>>>>>>>>>
>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>>>>> Computation Theory, this is not true. If you think it is, it
>>>>>>>>>>> just proves that you don't understand the field.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>>> If we know that we have a black cat then we know that we
>>>>>>>>>>>> have a cat.
>>>>>>>>>>>
>>>>>>>>>>> Except that if you DON'T have a black cat but think you do
>>>>>>>>>>> then you are wrong. If H aborts its simulation, it isn't a
>>>>>>>>>>> UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>>>>> cannot possibly ever reach its final state then we know that
>>>>>>>>>>>> we have a non-halting sequence of configurations.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>>>
>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^ will be
>>>>>>>>>>> non-halting, but H is still wrong for not answering. If H
>>>>>>>>>>> does abort, then it hasn't proven anything, and it has been
>>>>>>>>>>> proven that it is wrong.
>>>>>>>>>>>
>>>>>>>>>>> FAIL
>>>>>>>>>>
>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>>>>> classic Olcott logical fallicy.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>>> understand what I am saying. This is proven on the basis that
>>>>>>>> what I am saying can be verified as true entirely on the basis
>>>>>>>> of the meaning of its words.
>>>>>>>
>>>>>>> Except that it has been shown that you keep on using the WRONG
>>>>>>> definitions of the words.
>>>>>>>
>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>>> non-halting, so will the UTM). Also you think that there can be a
>>>>>>> 'Correct Simulation' by something that is NOT actully a UTM.
>>>>>>>
>>>>>>> Care to show anywhere where your misdefinitions are support in
>>>>>>> the field fo Computation Theory.
>>>>>>>
>>>>>>> That just PROVES that you aren't actually working on the Halting
>>>>>>> Problem of Computation Theory.
>>>>>>>
>>>>>>>>
>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>> because you just don't know the field, so don't have any idea
>>>>>>>>> what is legal or not.
>>>>>>>>>
>>>>>>>>> Also note, you keep talking about needing 'Computer Scientists'
>>>>>>>>> to understand, that is really incorrect, you need to be able to
>>>>>>>>> explain it to someone who understands Computation Theory, which
>>>>>>>>> is a fairly specialized branch of Mathematics. Yes, it is part
>>>>>>>>> of the foundation of Computer Science, but isn't the sort of
>>>>>>>>> thing that a normal Computer Scientist will deal with day to day.
>>>>>>>>
>>>>>>>> I need someone to analyze what I am saying on the deep meaning
>>>>>>>> of what I am saying instead of mere rote memorized meanings from
>>>>>>>> textbooks.
>>>>>>>
>>>>>>> No, you need to learn that words have PRECISE meanings, and you
>>>>>>> aren't allowed to change them, no mwtter how much it 'makes
>>>>>>> sense' to do so.
>>>>>>>
>>>>>>>>
>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>> believe that the halt decider is supposed to evaluate its input
>>>>>>>> on the basis of some proxy for the actual behavior of this
>>>>>>>> actual input rather than the actual behavior specified by this
>>>>>>>> actual input.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>>>> DEFINITION of the Halting problems says that it is, because you
>>>>>>> don't actually understand the meaning of 'actual behavior'.
>>>>>>>
>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied to
>>>>>>> w halts, and to H,Qn if M applied to w will never halt.
>>>>>>>
>>>>>>
>>>>>> If you are supposed to report when Bill arrives at your house and
>>>>>> Sam arrives at you house and you really really believe that Sam's
>>>>>> arrival is a valid proxy for Bill's arrival then when I ask you
>>>>>> did Bill arrive at your house? you say "yes" even though correct
>>>>>> the answer is "no".
>>>>>
>>>>> You really like to make you Herrings Red, don't you.
>>>>>
>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM w
>>>>> is based on the behavior of M applied to w.
>>>>>
>>>>> YOU are the one making the wrong report.
>>>>
>>>> When anyone in the universe defines something besides the actual
>>>> behavior specified by the input to embedded_H as the only correct
>>>> halt status criterion measure that might as well say that cats are
>>>> not animals.
>>>>
>>>>
>>>
>>> Just shows your problem in comprehension, doesn't it. You just refuse
>>> to accept the definition because it doesn't match your idea of what
>>> you need.
>>>
>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>> defined, and it IS the behavior that the input specifes, The input to
>>> the decider is the description of a computation, and the actual
>>> behavior sepecified by the input is by defintion the behavior of that
>>> computation that the input describes.
>>>
>>> YOU are the one that wants to change it to not be the behavior
>>> specified by the input, but the behavior of the program that is
>>> processing the input. YOUR definition of the behavior has the problem
>>> that the behavior is no longer just specified by 'the input' but is
>>> also a function of what program you give that input to.
>>>
>>> Your logic is just not sound, and sometimes I wonder how sound your
>>> mind is.
>>>
>>> This statement of your just shows how you have lost touch with the
>>> reality of the situation. You seem to think the Univese must be wrong
>>> because it doesn't match your expectations. THAT is a sign of mental
>>> illness.
>>>
>>> FAIL.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will never
> Halt.
>
> you keep forgetting the conditions, which are important.
Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can transition
to Ĥ.qn causing Ĥ to transition to Ĥ.qn without contradiction.


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

<su0qei$cb0$1@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!7a25jG6pUKCqa0zKnKnvdg.user.46.165.242.75.POSTED!not-for-mail
From: pyt...@example.invalid (Python)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Date: Wed, 9 Feb 2022 17:34:26 +0100
Organization: Aioe.org NNTP Server
Message-ID: <su0qei$cb0$1@gioia.aioe.org>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="12640"; posting-host="7a25jG6pUKCqa0zKnKnvdg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: fr
 by: Python - Wed, 9 Feb 2022 16:34 UTC

olcott wrote:
....
> Someone with a PhD in computer science specializing in the theory of
> computation will understand.

That you are a kook and have no proof, sure.

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

<KgSMJ.47860$t2Bb.36697@fx98.iad>

 copy mid

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

 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!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<UgWLJ.9101$GjY3.7596@fx01.iad>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 407
Message-ID: <KgSMJ.47860$t2Bb.36697@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 11:49:45 -0500
X-Received-Bytes: 22099
 by: Richard Damon - Wed, 9 Feb 2022 16:49 UTC

On 2/9/22 11:31 AM, olcott wrote:
> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>
>> On 2/9/22 8:13 AM, olcott wrote:
>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched
>>>>>>>>>>>>>>>>>>>>>>>>>>> H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover
>>>>>>>>>>>>>>>>>>>>>>>>>> the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an "infinite
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>> is undecidable. That is all that I need to
>>>>>>>>>>>>>>>>>>>>>>>>> refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a finite
>>>>>>>>>>>>>>>>>>>>>>>>>> set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must be
>>>>>>>>>>>>>>>>>>>>>>>>> all knowing. To refute the proofs I merely need
>>>>>>>>>>>>>>>>>>>>>>>>> to show that their counter-example can be
>>>>>>>>>>>>>>>>>>>>>>>>> proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied
>>>>>>>>>>>>>>>>>>>>>>>> to <H^> <H^> goes to H.Qn, then by construction
>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> goes to H^.Qn, and halts, and since H,
>>>>>>>>>>>>>>>>>>>>>>>> to be an accurate Halt Decider, must only go to
>>>>>>>>>>>>>>>>>>>>>>>> H,Qn if the machine its input represents will
>>>>>>>>>>>>>>>>>>>>>>>> never halt. They you also don't seem to
>>>>>>>>>>>>>>>>>>>>>>>> understand that the computaton that <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>> represents IS H^ applied to <H^>. So, H was just
>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you
>>>>>>>>>>>>>>>>>>>>>>>> claim youhave, but only that you have amassed an
>>>>>>>>>>>>>>>>>>>>>>>> amazing pile of unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked yourself into
>>>>>>>>>>>>>>>>>>>>>>>> thinking you have shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science
>>>>>>>>>>>>>>>>>>>>>>> to understand that you are wrong and never will
>>>>>>>>>>>>>>>>>>>>>>> because you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory, using
>>>>>>>>>>>>>>>>>>>>>> Computation Theory Deffinitions, that is your
>>>>>>>>>>>>>>>>>>>>>> problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are deciders
>>>>>>>>>>>>>>>>>>>>>>> they are only accountable for computing the
>>>>>>>>>>>>>>>>>>>>>>> mapping from their input finite strings to an
>>>>>>>>>>>>>>>>>>>>>>> accept or reject state on the basis of whether or
>>>>>>>>>>>>>>>>>>>>>>> not their correctly simulated input could ever
>>>>>>>>>>>>>>>>>>>>>>> reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the behavior
>>>>>>>>>>>>>>>>>>>>>> of Computation that it is representation of, which
>>>>>>>>>>>>>>>>>>>>>> for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps
>>>>>>>>>>>>>>>>>>>>> for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>>>> to transition to ⟨Ĥ⟩.qn then the input to
>>>>>>>>>>>>>>>>>>>>> embedded_H meets the Linz definition of a sequence
>>>>>>>>>>>>>>>>>>>>> of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its input
>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the
>>>>>>>>>>>>>>>>>>> same three iterations:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly
>>>>>>>>>>>>>>>>>>> meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does
>>>>>>>>>>>>>>>>>> not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>> iterations of nested simulation to match the infinitely
>>>>>>>>>>>>>>>>> nested simulation pattern.
>>>>>>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is
>>>>>>>>>>>>>>>> using it will Halt,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the front.
>>>>>>>>>>>>>>> If someone comes in the back door (non-inputs) embedded_H
>>>>>>>>>>>>>>> is not even allowed to pay attention.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not the
>>>>>>>>>>>>>> behavior of H^ applied to <H^> you are lying about doing
>>>>>>>>>>>>>> the Halting Problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is true that the simulated input to embedded_H cannot
>>>>>>>>>>>>> possibly ever reach its final state of ⟨Ĥ⟩.qn, then nothing
>>>>>>>>>>>>> in the universe can possibly contradict the fact that the
>>>>>>>>>>>>> input specifies a non-halting sequences of configurations.
>>>>>>>>>>>>> If God himself said otherwise then God himself would be a
>>>>>>>>>>>>> liar.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and goes
>>>>>>>>>>>> to H.Qn, then the CORRECT simulation of its input (that done
>>>>>>>>>>>> by a REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>>>>>
>>>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct decider,
>>>>>>>>>>>> then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>>>>>> Computation Theory, this is not true. If you think it is, it
>>>>>>>>>>>> just proves that you don't understand the field.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>>> If we know that we have a black cat then we know that we
>>>>>>>>>>>>> have a cat.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that if you DON'T have a black cat but think you do
>>>>>>>>>>>> then you are wrong. If H aborts its simulation, it isn't a
>>>>>>>>>>>> UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>>>>>> cannot possibly ever reach its final state then we know
>>>>>>>>>>>>> that we have a non-halting sequence of configurations.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^ will
>>>>>>>>>>>> be non-halting, but H is still wrong for not answering. If H
>>>>>>>>>>>> does abort, then it hasn't proven anything, and it has been
>>>>>>>>>>>> proven that it is wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL
>>>>>>>>>>>
>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>> I don't care which, I need to up my game to computer scientists.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>>>>>> classic Olcott logical fallicy.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>>>> understand what I am saying. This is proven on the basis that
>>>>>>>>> what I am saying can be verified as true entirely on the basis
>>>>>>>>> of the meaning of its words.
>>>>>>>>
>>>>>>>> Except that it has been shown that you keep on using the WRONG
>>>>>>>> definitions of the words.
>>>>>>>>
>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>>>> non-halting, so will the UTM). Also you think that there can be
>>>>>>>> a 'Correct Simulation' by something that is NOT actully a UTM.
>>>>>>>>
>>>>>>>> Care to show anywhere where your misdefinitions are support in
>>>>>>>> the field fo Computation Theory.
>>>>>>>>
>>>>>>>> That just PROVES that you aren't actually working on the Halting
>>>>>>>> Problem of Computation Theory.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>> because you just don't know the field, so don't have any idea
>>>>>>>>>> what is legal or not.
>>>>>>>>>>
>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>> Scientists' to understand, that is really incorrect, you need
>>>>>>>>>> to be able to explain it to someone who understands
>>>>>>>>>> Computation Theory, which is a fairly specialized branch of
>>>>>>>>>> Mathematics. Yes, it is part of the foundation of Computer
>>>>>>>>>> Science, but isn't the sort of thing that a normal Computer
>>>>>>>>>> Scientist will deal with day to day.
>>>>>>>>>
>>>>>>>>> I need someone to analyze what I am saying on the deep meaning
>>>>>>>>> of what I am saying instead of mere rote memorized meanings
>>>>>>>>> from textbooks.
>>>>>>>>
>>>>>>>> No, you need to learn that words have PRECISE meanings, and you
>>>>>>>> aren't allowed to change them, no mwtter how much it 'makes
>>>>>>>> sense' to do so.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>> believe that the halt decider is supposed to evaluate its input
>>>>>>>>> on the basis of some proxy for the actual behavior of this
>>>>>>>>> actual input rather than the actual behavior specified by this
>>>>>>>>> actual input.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>>>>> DEFINITION of the Halting problems says that it is, because you
>>>>>>>> don't actually understand the meaning of 'actual behavior'.
>>>>>>>>
>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied
>>>>>>>> to w halts, and to H,Qn if M applied to w will never halt.
>>>>>>>>
>>>>>>>
>>>>>>> If you are supposed to report when Bill arrives at your house and
>>>>>>> Sam arrives at you house and you really really believe that Sam's
>>>>>>> arrival is a valid proxy for Bill's arrival then when I ask you
>>>>>>> did Bill arrive at your house? you say "yes" even though correct
>>>>>>> the answer is "no".
>>>>>>
>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>
>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM
>>>>>> w is based on the behavior of M applied to w.
>>>>>>
>>>>>> YOU are the one making the wrong report.
>>>>>
>>>>> When anyone in the universe defines something besides the actual
>>>>> behavior specified by the input to embedded_H as the only correct
>>>>> halt status criterion measure that might as well say that cats are
>>>>> not animals.
>>>>>
>>>>>
>>>>
>>>> Just shows your problem in comprehension, doesn't it. You just
>>>> refuse to accept the definition because it doesn't match your idea
>>>> of what you need.
>>>>
>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>> defined, and it IS the behavior that the input specifes, The input
>>>> to the decider is the description of a computation, and the actual
>>>> behavior sepecified by the input is by defintion the behavior of
>>>> that computation that the input describes.
>>>>
>>>> YOU are the one that wants to change it to not be the behavior
>>>> specified by the input, but the behavior of the program that is
>>>> processing the input. YOUR definition of the behavior has the
>>>> problem that the behavior is no longer just specified by 'the input'
>>>> but is also a function of what program you give that input to.
>>>>
>>>> Your logic is just not sound, and sometimes I wonder how sound your
>>>> mind is.
>>>>
>>>> This statement of your just shows how you have lost touch with the
>>>> reality of the situation. You seem to think the Univese must be
>>>> wrong because it doesn't match your expectations. THAT is a sign of
>>>> mental illness.
>>>>
>>>> FAIL.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>> never Halt.
>>
>> you keep forgetting the conditions, which are important.
> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
> than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can transition
> to Ĥ.qn causing Ĥ to transition to Ĥ.qn without contradiction.


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

<coCdnQWMy7yHaZ7_nZ2dnUU7-WnNnZ2d@giganews.com>

 copy mid

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

 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!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 11:04:26 -0600
Date: Wed, 9 Feb 2022 11:04:25 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com> <su0qei$cb0$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <su0qei$cb0$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <coCdnQWMy7yHaZ7_nZ2dnUU7-WnNnZ2d@giganews.com>
Lines: 21
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5seO3vwvNmZ3a1eO/CO50jbkjN6SgRgxnjOGq7hXk2CuSc/zjiRB6kCPg0/CALKkquv1mchGWAKeZZs!GSsXoxo04a0glXOEGwV2G6J1zYVrdtCAxlQVw15H2ukIAyoUqRaESjFNBo3489ii6YI4I2zs6l1V
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: 2842
 by: olcott - Wed, 9 Feb 2022 17:04 UTC

On 2/9/2022 10:34 AM, Python wrote:
> olcott wrote:
> ...
>> Someone with a PhD in computer science specializing in the theory of
>> computation will understand.
>
> That you are a kook and have no proof, sure.
>
>

The only "mistake" that anyone has pointed out with my most recent
version is that they do not believe that a halt decider is supposed to
report on the actual behavior specified by its actual input. This is the
same thing as them saying that they believe that a cat is a dog.

--
Copyright 2021 Pete Olcott

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

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

<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 11:08:42 -0600
Date: Wed, 9 Feb 2022 11:08:41 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<o6OdnWcKZpf-qJ3_nZ2dnUU7-YXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <KgSMJ.47860$t2Bb.36697@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
Lines: 377
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ORqsFAEk9O/bIGfY0t2aTE7ceXnGlNVnJx2o0lpLWzCxCKtQPPiLdo3l6aGXOluGDOfru6ZoQI1+7YE!E/xCyF4BPD2kNv79sHtP15osZL/HZetNdBjrX4RaOatqqeRZmOBbNrYRMj3GCf8Hdw+WkPCaY2vz
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: 21192
 by: olcott - Wed, 9 Feb 2022 17:08 UTC

On 2/9/2022 10:49 AM, Richard Damon wrote:
> On 2/9/22 11:31 AM, olcott wrote:
>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>
>>> On 2/9/22 8:13 AM, olcott wrote:
>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is matched
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover
>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>> problem is undecidable. That is all that I
>>>>>>>>>>>>>>>>>>>>>>>>>> need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must
>>>>>>>>>>>>>>>>>>>>>>>>>> be all knowing. To refute the proofs I merely
>>>>>>>>>>>>>>>>>>>>>>>>>> need to show that their counter-example can be
>>>>>>>>>>>>>>>>>>>>>>>>>> proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied
>>>>>>>>>>>>>>>>>>>>>>>>> to <H^> <H^> goes to H.Qn, then by construction
>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> goes to H^.Qn, and halts, and since H,
>>>>>>>>>>>>>>>>>>>>>>>>> to be an accurate Halt Decider, must only go to
>>>>>>>>>>>>>>>>>>>>>>>>> H,Qn if the machine its input represents will
>>>>>>>>>>>>>>>>>>>>>>>>> never halt. They you also don't seem to
>>>>>>>>>>>>>>>>>>>>>>>>> understand that the computaton that <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>> represents IS H^ applied to <H^>. So, H was
>>>>>>>>>>>>>>>>>>>>>>>>> just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you
>>>>>>>>>>>>>>>>>>>>>>>>> claim youhave, but only that you have amassed
>>>>>>>>>>>>>>>>>>>>>>>>> an amazing pile of unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked yourself into
>>>>>>>>>>>>>>>>>>>>>>>>> thinking you have shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science
>>>>>>>>>>>>>>>>>>>>>>>> to understand that you are wrong and never will
>>>>>>>>>>>>>>>>>>>>>>>> because you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory,
>>>>>>>>>>>>>>>>>>>>>>> using Computation Theory Deffinitions, that is
>>>>>>>>>>>>>>>>>>>>>>> your problem.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for computing
>>>>>>>>>>>>>>>>>>>>>>>> the mapping from their input finite strings to
>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
>>>>>>>>>>>>>>>>>>>>>>>> whether or not their correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>> could ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning of
>>>>>>>>>>>>>>>>>>>>>>> 'correcty simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the behavior
>>>>>>>>>>>>>>>>>>>>>>> of Computation that it is representation of,
>>>>>>>>>>>>>>>>>>>>>>> which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough steps
>>>>>>>>>>>>>>>>>>>>>> for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>> embedded_H to transition to ⟨Ĥ⟩.qn then the input
>>>>>>>>>>>>>>>>>>>>>> to embedded_H meets the Linz definition of a
>>>>>>>>>>>>>>>>>>>>>> sequence of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its
>>>>>>>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in the
>>>>>>>>>>>>>>>>>>>> same three iterations:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly
>>>>>>>>>>>>>>>>>>>> meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does
>>>>>>>>>>>>>>>>>>> not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this pattern.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that is
>>>>>>>>>>>>>>>>> using it will Halt,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the
>>>>>>>>>>>>>>>> front. If someone comes in the back door (non-inputs)
>>>>>>>>>>>>>>>> embedded_H is not even allowed to pay attention.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not
>>>>>>>>>>>>>>> the behavior of H^ applied to <H^> you are lying about
>>>>>>>>>>>>>>> doing the Halting Problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>> cannot possibly ever reach its final state of ⟨Ĥ⟩.qn, then
>>>>>>>>>>>>>> nothing in the universe can possibly contradict the fact
>>>>>>>>>>>>>> that the input specifies a non-halting sequences of
>>>>>>>>>>>>>> configurations. If God himself said otherwise then God
>>>>>>>>>>>>>> himself would be a liar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and goes
>>>>>>>>>>>>> to H.Qn, then the CORRECT simulation of its input (that
>>>>>>>>>>>>> done by a REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct decider,
>>>>>>>>>>>>> then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>>>>>>> Computation Theory, this is not true. If you think it is,
>>>>>>>>>>>>> it just proves that you don't understand the field.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> If we know that we have a black cat then we know that we
>>>>>>>>>>>>>> have a cat.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that if you DON'T have a black cat but think you do
>>>>>>>>>>>>> then you are wrong. If H aborts its simulation, it isn't a
>>>>>>>>>>>>> UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>>>>>>> cannot possibly ever reach its final state then we know
>>>>>>>>>>>>>> that we have a non-halting sequence of configurations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^ will
>>>>>>>>>>>>> be non-halting, but H is still wrong for not answering. If
>>>>>>>>>>>>> H does abort, then it hasn't proven anything, and it has
>>>>>>>>>>>>> been proven that it is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>
>>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>> scientists.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>>>>>>> classic Olcott logical fallicy.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>>>>> understand what I am saying. This is proven on the basis that
>>>>>>>>>> what I am saying can be verified as true entirely on the basis
>>>>>>>>>> of the meaning of its words.
>>>>>>>>>
>>>>>>>>> Except that it has been shown that you keep on using the WRONG
>>>>>>>>> definitions of the words.
>>>>>>>>>
>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>>>>> non-halting, so will the UTM). Also you think that there can be
>>>>>>>>> a 'Correct Simulation' by something that is NOT actully a UTM.
>>>>>>>>>
>>>>>>>>> Care to show anywhere where your misdefinitions are support in
>>>>>>>>> the field fo Computation Theory.
>>>>>>>>>
>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>>> because you just don't know the field, so don't have any idea
>>>>>>>>>>> what is legal or not.
>>>>>>>>>>>
>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>> Scientists' to understand, that is really incorrect, you need
>>>>>>>>>>> to be able to explain it to someone who understands
>>>>>>>>>>> Computation Theory, which is a fairly specialized branch of
>>>>>>>>>>> Mathematics. Yes, it is part of the foundation of Computer
>>>>>>>>>>> Science, but isn't the sort of thing that a normal Computer
>>>>>>>>>>> Scientist will deal with day to day.
>>>>>>>>>>
>>>>>>>>>> I need someone to analyze what I am saying on the deep meaning
>>>>>>>>>> of what I am saying instead of mere rote memorized meanings
>>>>>>>>>> from textbooks.
>>>>>>>>>
>>>>>>>>> No, you need to learn that words have PRECISE meanings, and you
>>>>>>>>> aren't allowed to change them, no mwtter how much it 'makes
>>>>>>>>> sense' to do so.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>>> believe that the halt decider is supposed to evaluate its
>>>>>>>>>> input on the basis of some proxy for the actual behavior of
>>>>>>>>>> this actual input rather than the actual behavior specified by
>>>>>>>>>> this actual input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>>>>>> DEFINITION of the Halting problems says that it is, because you
>>>>>>>>> don't actually understand the meaning of 'actual behavior'.
>>>>>>>>>
>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied
>>>>>>>>> to w halts, and to H,Qn if M applied to w will never halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you are supposed to report when Bill arrives at your house
>>>>>>>> and Sam arrives at you house and you really really believe that
>>>>>>>> Sam's arrival is a valid proxy for Bill's arrival then when I
>>>>>>>> ask you did Bill arrive at your house? you say "yes" even though
>>>>>>>> correct the answer is "no".
>>>>>>>
>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>
>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to wM
>>>>>>> w is based on the behavior of M applied to w.
>>>>>>>
>>>>>>> YOU are the one making the wrong report.
>>>>>>
>>>>>> When anyone in the universe defines something besides the actual
>>>>>> behavior specified by the input to embedded_H as the only correct
>>>>>> halt status criterion measure that might as well say that cats are
>>>>>> not animals.
>>>>>>
>>>>>>
>>>>>
>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>> refuse to accept the definition because it doesn't match your idea
>>>>> of what you need.
>>>>>
>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>> defined, and it IS the behavior that the input specifes, The input
>>>>> to the decider is the description of a computation, and the actual
>>>>> behavior sepecified by the input is by defintion the behavior of
>>>>> that computation that the input describes.
>>>>>
>>>>> YOU are the one that wants to change it to not be the behavior
>>>>> specified by the input, but the behavior of the program that is
>>>>> processing the input. YOUR definition of the behavior has the
>>>>> problem that the behavior is no longer just specified by 'the
>>>>> input' but is also a function of what program you give that input to.
>>>>>
>>>>> Your logic is just not sound, and sometimes I wonder how sound your
>>>>> mind is.
>>>>>
>>>>> This statement of your just shows how you have lost touch with the
>>>>> reality of the situation. You seem to think the Univese must be
>>>>> wrong because it doesn't match your expectations. THAT is a sign of
>>>>> mental illness.
>>>>>
>>>>> FAIL.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>> never Halt.
>>>
>>> you keep forgetting the conditions, which are important.
>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
>> than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can transition
>> to Ĥ.qn causing Ĥ to transition to Ĥ.qn without contradiction.
>
> Bing a pathological liar seems to have made you lose your sense of what
> is true.
>
> While H^ applied to <H^> IS a different computation then H applied to
> <H^> <H^> the former uses the latter to determine its behavior.
>
> The issue isn't a 'contradiction' between the behavior of the two
> machines but the contradiction between the behavior of these two
> machines and the concept that H is correct.
>
>>
>> Like the guard that is only accountable for guarding the front door
>> simulating halt decider embedded_H is only accountable for reporting
>> whether or not its simulated input can possibly reach its own final
>> state ⟨Ĥ⟩.qn.
>
> Again, you pathological lying has blinded you to the actual fact.
>
> H/embedded_H IS responsible for its answer match the the ACTUAL
> 'Behavior of its input', which is DEFINED as the behavior of the ACTUAL
> MACHINE the input represents.


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

<zXSMJ.7936$979a.7156@fx14.iad>

 copy mid

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

 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!fx14.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 403
Message-ID: <zXSMJ.7936$979a.7156@fx14.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 12:35:26 -0500
X-Received-Bytes: 22318
 by: Richard Damon - Wed, 9 Feb 2022 17:35 UTC

On 2/9/22 12:08 PM, olcott wrote:
> On 2/9/2022 10:49 AM, Richard Damon wrote:
>> On 2/9/22 11:31 AM, olcott wrote:
>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>
>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not cover
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is undecidable. That is all that I
>>>>>>>>>>>>>>>>>>>>>>>>>>> need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must
>>>>>>>>>>>>>>>>>>>>>>>>>>> be all knowing. To refute the proofs I merely
>>>>>>>>>>>>>>>>>>>>>>>>>>> need to show that their counter-example can
>>>>>>>>>>>>>>>>>>>>>>>>>>> be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H applied
>>>>>>>>>>>>>>>>>>>>>>>>>> to <H^> <H^> goes to H.Qn, then by
>>>>>>>>>>>>>>>>>>>>>>>>>> construction H^ <H^> goes to H^.Qn, and halts,
>>>>>>>>>>>>>>>>>>>>>>>>>> and since H, to be an accurate Halt Decider,
>>>>>>>>>>>>>>>>>>>>>>>>>> must only go to H,Qn if the machine its input
>>>>>>>>>>>>>>>>>>>>>>>>>> represents will never halt. They you also
>>>>>>>>>>>>>>>>>>>>>>>>>> don't seem to understand that the computaton
>>>>>>>>>>>>>>>>>>>>>>>>>> that <H^> <H^> represents IS H^ applied to
>>>>>>>>>>>>>>>>>>>>>>>>>> <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you
>>>>>>>>>>>>>>>>>>>>>>>>>> claim youhave, but only that you have amassed
>>>>>>>>>>>>>>>>>>>>>>>>>> an amazing pile of unsound logic based on
>>>>>>>>>>>>>>>>>>>>>>>>>> wrong definitions that have hoodwinked
>>>>>>>>>>>>>>>>>>>>>>>>>> yourself into thinking you have shown
>>>>>>>>>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer science
>>>>>>>>>>>>>>>>>>>>>>>>> to understand that you are wrong and never will
>>>>>>>>>>>>>>>>>>>>>>>>> because you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory,
>>>>>>>>>>>>>>>>>>>>>>>> using Computation Theory Deffinitions, that is
>>>>>>>>>>>>>>>>>>>>>>>> your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input finite
>>>>>>>>>>>>>>>>>>>>>>>>> strings to an accept or reject state on the
>>>>>>>>>>>>>>>>>>>>>>>>> basis of whether or not their correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulated input could ever reach its final
>>>>>>>>>>>>>>>>>>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory, BY DEFINITION, the meaning
>>>>>>>>>>>>>>>>>>>>>>>> of 'correcty simulted' is simulation by a REAL
>>>>>>>>>>>>>>>>>>>>>>>> UTM which BY DEFINITION exactly matches the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^> is H^
>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough
>>>>>>>>>>>>>>>>>>>>>>> steps for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>> embedded_H to transition to ⟨Ĥ⟩.qn then the input
>>>>>>>>>>>>>>>>>>>>>>> to embedded_H meets the Linz definition of a
>>>>>>>>>>>>>>>>>>>>>>> sequence of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps and
>>>>>>>>>>>>>>>>>>>>>> doesn't reach a final state, then it shows its
>>>>>>>>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in
>>>>>>>>>>>>>>>>>>>>> the same three iterations:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number of
>>>>>>>>>>>>>>>>>>>>> steps, which proves that this input cannot possibly
>>>>>>>>>>>>>>>>>>>>> meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that does
>>>>>>>>>>>>>>>>>>>> not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this
>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that
>>>>>>>>>>>>>>>>>> is using it will Halt,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the
>>>>>>>>>>>>>>>>> front. If someone comes in the back door (non-inputs)
>>>>>>>>>>>>>>>>> embedded_H is not even allowed to pay attention.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not
>>>>>>>>>>>>>>>> the behavior of H^ applied to <H^> you are lying about
>>>>>>>>>>>>>>>> doing the Halting Problem.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>>> cannot possibly ever reach its final state of ⟨Ĥ⟩.qn,
>>>>>>>>>>>>>>> then nothing in the universe can possibly contradict the
>>>>>>>>>>>>>>> fact that the input specifies a non-halting sequences of
>>>>>>>>>>>>>>> configurations. If God himself said otherwise then God
>>>>>>>>>>>>>>> himself would be a liar.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and goes
>>>>>>>>>>>>>> to H.Qn, then the CORRECT simulation of its input (that
>>>>>>>>>>>>>> done by a REAL UTM) will show that it will go to H^.Qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct
>>>>>>>>>>>>>> decider, then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>>>> simulation is a 'correct' simulation. By the definition in
>>>>>>>>>>>>>> Computation Theory, this is not true. If you think it is,
>>>>>>>>>>>>>> it just proves that you don't understand the field.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If we know that we have a black cat then we know that we
>>>>>>>>>>>>>>> have a cat.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think you do
>>>>>>>>>>>>>> then you are wrong. If H aborts its simulation, it isn't a
>>>>>>>>>>>>>> UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If we know that we have a sequence of configurations that
>>>>>>>>>>>>>>> cannot possibly ever reach its final state then we know
>>>>>>>>>>>>>>> that we have a non-halting sequence of configurations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^ will
>>>>>>>>>>>>>> be non-halting, but H is still wrong for not answering. If
>>>>>>>>>>>>>> H does abort, then it hasn't proven anything, and it has
>>>>>>>>>>>>>> been proven that it is wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, can't refute what I say so you go to arguing by insults,
>>>>>>>>>>>> classic Olcott logical fallicy.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>>>>>> understand what I am saying. This is proven on the basis that
>>>>>>>>>>> what I am saying can be verified as true entirely on the
>>>>>>>>>>> basis of the meaning of its words.
>>>>>>>>>>
>>>>>>>>>> Except that it has been shown that you keep on using the WRONG
>>>>>>>>>> definitions of the words.
>>>>>>>>>>
>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>>>>>> non-halting, so will the UTM). Also you think that there can
>>>>>>>>>> be a 'Correct Simulation' by something that is NOT actully a UTM.
>>>>>>>>>>
>>>>>>>>>> Care to show anywhere where your misdefinitions are support in
>>>>>>>>>> the field fo Computation Theory.
>>>>>>>>>>
>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>>>> because you just don't know the field, so don't have any
>>>>>>>>>>>> idea what is legal or not.
>>>>>>>>>>>>
>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>> Scientists' to understand, that is really incorrect, you
>>>>>>>>>>>> need to be able to explain it to someone who understands
>>>>>>>>>>>> Computation Theory, which is a fairly specialized branch of
>>>>>>>>>>>> Mathematics. Yes, it is part of the foundation of Computer
>>>>>>>>>>>> Science, but isn't the sort of thing that a normal Computer
>>>>>>>>>>>> Scientist will deal with day to day.
>>>>>>>>>>>
>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>> meaning of what I am saying instead of mere rote memorized
>>>>>>>>>>> meanings from textbooks.
>>>>>>>>>>
>>>>>>>>>> No, you need to learn that words have PRECISE meanings, and
>>>>>>>>>> you aren't allowed to change them, no mwtter how much it
>>>>>>>>>> 'makes sense' to do so.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>>>> believe that the halt decider is supposed to evaluate its
>>>>>>>>>>> input on the basis of some proxy for the actual behavior of
>>>>>>>>>>> this actual input rather than the actual behavior specified
>>>>>>>>>>> by this actual input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>>>>>>> DEFINITION of the Halting problems says that it is, because
>>>>>>>>>> you don't actually understand the meaning of 'actual behavior'.
>>>>>>>>>>
>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M applied
>>>>>>>>>> to w halts, and to H,Qn if M applied to w will never halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you are supposed to report when Bill arrives at your house
>>>>>>>>> and Sam arrives at you house and you really really believe that
>>>>>>>>> Sam's arrival is a valid proxy for Bill's arrival then when I
>>>>>>>>> ask you did Bill arrive at your house? you say "yes" even
>>>>>>>>> though correct the answer is "no".
>>>>>>>>
>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>
>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to
>>>>>>>> wM w is based on the behavior of M applied to w.
>>>>>>>>
>>>>>>>> YOU are the one making the wrong report.
>>>>>>>
>>>>>>> When anyone in the universe defines something besides the actual
>>>>>>> behavior specified by the input to embedded_H as the only correct
>>>>>>> halt status criterion measure that might as well say that cats
>>>>>>> are not animals.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>> refuse to accept the definition because it doesn't match your idea
>>>>>> of what you need.
>>>>>>
>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>> defined, and it IS the behavior that the input specifes, The input
>>>>>> to the decider is the description of a computation, and the actual
>>>>>> behavior sepecified by the input is by defintion the behavior of
>>>>>> that computation that the input describes.
>>>>>>
>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>> specified by the input, but the behavior of the program that is
>>>>>> processing the input. YOUR definition of the behavior has the
>>>>>> problem that the behavior is no longer just specified by 'the
>>>>>> input' but is also a function of what program you give that input to.
>>>>>>
>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>> your mind is.
>>>>>>
>>>>>> This statement of your just shows how you have lost touch with the
>>>>>> reality of the situation. You seem to think the Univese must be
>>>>>> wrong because it doesn't match your expectations. THAT is a sign
>>>>>> of mental illness.
>>>>>>
>>>>>> FAIL.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will Halt.
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>>> never Halt.
>>>>
>>>> you keep forgetting the conditions, which are important.
>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
>>> than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can
>>> transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn without
>>> contradiction.
>>
>> Bing a pathological liar seems to have made you lose your sense of
>> what is true.
>>
>> While H^ applied to <H^> IS a different computation then H applied to
>> <H^> <H^> the former uses the latter to determine its behavior.
>>
>> The issue isn't a 'contradiction' between the behavior of the two
>> machines but the contradiction between the behavior of these two
>> machines and the concept that H is correct.
>>
>>>
>>> Like the guard that is only accountable for guarding the front door
>>> simulating halt decider embedded_H is only accountable for reporting
>>> whether or not its simulated input can possibly reach its own final
>>> state ⟨Ĥ⟩.qn.
>>
>> Again, you pathological lying has blinded you to the actual fact.
>>
>> H/embedded_H IS responsible for its answer match the the ACTUAL
>> 'Behavior of its input', which is DEFINED as the behavior of the
>> ACTUAL MACHINE the input represents.
>
> You have this misconception welded into your brain.
> That is just like asking did Bill come over last night?
>
> You answer yes because Bill's lawyer came over and Bill's lawyer
> represents Bill.
>
>


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

<a_SMJ.7937$979a.1691@fx14.iad>

 copy mid

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

 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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx14.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<feXLJ.39132$%uX7.7402@fx38.iad>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com> <su0qei$cb0$1@gioia.aioe.org>
<coCdnQWMy7yHaZ7_nZ2dnUU7-WnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <coCdnQWMy7yHaZ7_nZ2dnUU7-WnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 32
Message-ID: <a_SMJ.7937$979a.1691@fx14.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 12:38:14 -0500
X-Received-Bytes: 2938
 by: Richard Damon - Wed, 9 Feb 2022 17:38 UTC

On 2/9/22 12:04 PM, olcott wrote:
> On 2/9/2022 10:34 AM, Python wrote:
>> olcott wrote:
>> ...
>>> Someone with a PhD in computer science specializing in the theory of
>>> computation will understand.
>>
>> That you are a kook and have no proof, sure.
>>
>>
>
> The only "mistake" that anyone has pointed out with my most recent
> version is that they do not believe that a halt decider is supposed to
> report on the actual behavior specified by its actual input. This is the
> same thing as them saying that they believe that a cat is a dog.
>

More of your basic lies.

From the definition of a Halt Decider, H applied to wM w needs to
report on the behavior of M applied to w.

Thus H applied to <H^> <H^> needs to report on the behavior of H^
applied to <H^>. PERIOD.

THAT is the ACTUAL BEHAVIOR that H needs to report on.

You keep on trying to claim that it is something else, thus you are not
working on the Halting Problem, but something else.

FAIL.

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

<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 12:39:45 -0600
Date: Wed, 9 Feb 2022 12:39:44 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<2aydnRLgIrPLEZ3_nZ2dnUU7-bHNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <zXSMJ.7936$979a.7156@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
Lines: 409
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-C4o3d8CWIe/bchEr9rxzyxRvIx00XgDSM8LS3sznxV3sbVhm33Q6nn9sNY5rE8bGxhhqa5GgtNRlCb3!hmZXsSTTOPOLfNu/fBordT24+uFsKDmjOC/Dhp9F9Num3SIbYWWsx1qO9yx+GGPpOGSf0Ntkyn3x
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: 23076
 by: olcott - Wed, 9 Feb 2022 18:39 UTC

On 2/9/2022 11:35 AM, Richard Damon wrote:
> On 2/9/22 12:08 PM, olcott wrote:
>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>> On 2/9/22 11:31 AM, olcott wrote:
>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>
>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is undecidable. That is all that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>> need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program must
>>>>>>>>>>>>>>>>>>>>>>>>>>>> be all knowing. To refute the proofs I
>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely need to show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then by
>>>>>>>>>>>>>>>>>>>>>>>>>>> construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider, must only go to H,Qn if the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> its input represents will never halt. They
>>>>>>>>>>>>>>>>>>>>>>>>>>> you also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^
>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing you
>>>>>>>>>>>>>>>>>>>>>>>>>>> claim youhave, but only that you have amassed
>>>>>>>>>>>>>>>>>>>>>>>>>>> an amazing pile of unsound logic based on
>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong definitions that have hoodwinked
>>>>>>>>>>>>>>>>>>>>>>>>>>> yourself into thinking you have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong and
>>>>>>>>>>>>>>>>>>>>>>>>>> never will because you believe that you are
>>>>>>>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory,
>>>>>>>>>>>>>>>>>>>>>>>>> using Computation Theory Deffinitions, that is
>>>>>>>>>>>>>>>>>>>>>>>>> your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input finite
>>>>>>>>>>>>>>>>>>>>>>>>>> strings to an accept or reject state on the
>>>>>>>>>>>>>>>>>>>>>>>>>> basis of whether or not their correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input could ever reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem
>>>>>>>>>>>>>>>>>>>>>>>>> of Computation Theory, BY DEFINITION, the
>>>>>>>>>>>>>>>>>>>>>>>>> meaning of 'correcty simulted' is simulation by
>>>>>>>>>>>>>>>>>>>>>>>>> a REAL UTM which BY DEFINITION exactly matches
>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^> is H^
>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough
>>>>>>>>>>>>>>>>>>>>>>>> steps for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to transition to ⟨Ĥ⟩.qn then the
>>>>>>>>>>>>>>>>>>>>>>>> input to embedded_H meets the Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>> a sequence of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps
>>>>>>>>>>>>>>>>>>>>>>> and doesn't reach a final state, then it shows
>>>>>>>>>>>>>>>>>>>>>>> its input never halts.
>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in
>>>>>>>>>>>>>>>>>>>>>> the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number
>>>>>>>>>>>>>>>>>>>>>> of steps, which proves that this input cannot
>>>>>>>>>>>>>>>>>>>>>> possibly meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that
>>>>>>>>>>>>>>>>>>>>> does not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this
>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that
>>>>>>>>>>>>>>>>>>> is using it will Halt,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the
>>>>>>>>>>>>>>>>>> front. If someone comes in the back door (non-inputs)
>>>>>>>>>>>>>>>>>> embedded_H is not even allowed to pay attention.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not
>>>>>>>>>>>>>>>>> the behavior of H^ applied to <H^> you are lying about
>>>>>>>>>>>>>>>>> doing the Halting Problem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>>>> cannot possibly ever reach its final state of ⟨Ĥ⟩.qn,
>>>>>>>>>>>>>>>> then nothing in the universe can possibly contradict the
>>>>>>>>>>>>>>>> fact that the input specifies a non-halting sequences of
>>>>>>>>>>>>>>>> configurations. If God himself said otherwise then God
>>>>>>>>>>>>>>>> himself would be a liar.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and
>>>>>>>>>>>>>>> goes to H.Qn, then the CORRECT simulation of its input
>>>>>>>>>>>>>>> (that done by a REAL UTM) will show that it will go to
>>>>>>>>>>>>>>> H^.Qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct
>>>>>>>>>>>>>>> decider, then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>>>>> simulation is a 'correct' simulation. By the definition
>>>>>>>>>>>>>>> in Computation Theory, this is not true. If you think it
>>>>>>>>>>>>>>> is, it just proves that you don't understand the field.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If we know that we have a black cat then we know that we
>>>>>>>>>>>>>>>> have a cat.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think you
>>>>>>>>>>>>>>> do then you are wrong. If H aborts its simulation, it
>>>>>>>>>>>>>>> isn't a UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If we know that we have a sequence of configurations
>>>>>>>>>>>>>>>> that cannot possibly ever reach its final state then we
>>>>>>>>>>>>>>>> know that we have a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then the
>>>>>>>>>>>>>>> pattern WILL reach the final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^
>>>>>>>>>>>>>>> will be non-halting, but H is still wrong for not
>>>>>>>>>>>>>>> answering. If H does abort, then it hasn't proven
>>>>>>>>>>>>>>> anything, and it has been proven that it is wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>>>>>>> understand what I am saying. This is proven on the basis
>>>>>>>>>>>> that what I am saying can be verified as true entirely on
>>>>>>>>>>>> the basis of the meaning of its words.
>>>>>>>>>>>
>>>>>>>>>>> Except that it has been shown that you keep on using the
>>>>>>>>>>> WRONG definitions of the words.
>>>>>>>>>>>
>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>>>>>>> non-halting, so will the UTM). Also you think that there can
>>>>>>>>>>> be a 'Correct Simulation' by something that is NOT actully a
>>>>>>>>>>> UTM.
>>>>>>>>>>>
>>>>>>>>>>> Care to show anywhere where your misdefinitions are support
>>>>>>>>>>> in the field fo Computation Theory.
>>>>>>>>>>>
>>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>>>>> because you just don't know the field, so don't have any
>>>>>>>>>>>>> idea what is legal or not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>> Scientists' to understand, that is really incorrect, you
>>>>>>>>>>>>> need to be able to explain it to someone who understands
>>>>>>>>>>>>> Computation Theory, which is a fairly specialized branch of
>>>>>>>>>>>>> Mathematics. Yes, it is part of the foundation of Computer
>>>>>>>>>>>>> Science, but isn't the sort of thing that a normal Computer
>>>>>>>>>>>>> Scientist will deal with day to day.
>>>>>>>>>>>>
>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>> meaning of what I am saying instead of mere rote memorized
>>>>>>>>>>>> meanings from textbooks.
>>>>>>>>>>>
>>>>>>>>>>> No, you need to learn that words have PRECISE meanings, and
>>>>>>>>>>> you aren't allowed to change them, no mwtter how much it
>>>>>>>>>>> 'makes sense' to do so.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>>>>> believe that the halt decider is supposed to evaluate its
>>>>>>>>>>>> input on the basis of some proxy for the actual behavior of
>>>>>>>>>>>> this actual input rather than the actual behavior specified
>>>>>>>>>>>> by this actual input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Just proves you aren't working on the Halting Problem, as the
>>>>>>>>>>> DEFINITION of the Halting problems says that it is, because
>>>>>>>>>>> you don't actually understand the meaning of 'actual behavior'.
>>>>>>>>>>>
>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will never
>>>>>>>>>>> halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If you are supposed to report when Bill arrives at your house
>>>>>>>>>> and Sam arrives at you house and you really really believe
>>>>>>>>>> that Sam's arrival is a valid proxy for Bill's arrival then
>>>>>>>>>> when I ask you did Bill arrive at your house? you say "yes"
>>>>>>>>>> even though correct the answer is "no".
>>>>>>>>>
>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>
>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to
>>>>>>>>> wM w is based on the behavior of M applied to w.
>>>>>>>>>
>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>
>>>>>>>> When anyone in the universe defines something besides the actual
>>>>>>>> behavior specified by the input to embedded_H as the only
>>>>>>>> correct halt status criterion measure that might as well say
>>>>>>>> that cats are not animals.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>>> refuse to accept the definition because it doesn't match your
>>>>>>> idea of what you need.
>>>>>>>
>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>>> defined, and it IS the behavior that the input specifes, The
>>>>>>> input to the decider is the description of a computation, and the
>>>>>>> actual behavior sepecified by the input is by defintion the
>>>>>>> behavior of that computation that the input describes.
>>>>>>>
>>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>>> specified by the input, but the behavior of the program that is
>>>>>>> processing the input. YOUR definition of the behavior has the
>>>>>>> problem that the behavior is no longer just specified by 'the
>>>>>>> input' but is also a function of what program you give that input
>>>>>>> to.
>>>>>>>
>>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>>> your mind is.
>>>>>>>
>>>>>>> This statement of your just shows how you have lost touch with
>>>>>>> the reality of the situation. You seem to think the Univese must
>>>>>>> be wrong because it doesn't match your expectations. THAT is a
>>>>>>> sign of mental illness.
>>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will
>>>>> Halt.
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>>>> never Halt.
>>>>>
>>>>> you keep forgetting the conditions, which are important.
>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of configurations
>>>> than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore embedded_H can
>>>> transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn without
>>>> contradiction.
>>>
>>> Bing a pathological liar seems to have made you lose your sense of
>>> what is true.
>>>
>>> While H^ applied to <H^> IS a different computation then H applied to
>>> <H^> <H^> the former uses the latter to determine its behavior.
>>>
>>> The issue isn't a 'contradiction' between the behavior of the two
>>> machines but the contradiction between the behavior of these two
>>> machines and the concept that H is correct.
>>>
>>>>
>>>> Like the guard that is only accountable for guarding the front door
>>>> simulating halt decider embedded_H is only accountable for reporting
>>>> whether or not its simulated input can possibly reach its own final
>>>> state ⟨Ĥ⟩.qn.
>>>
>>> Again, you pathological lying has blinded you to the actual fact.
>>>
>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>> ACTUAL MACHINE the input represents.
>>
>> You have this misconception welded into your brain.
>> That is just like asking did Bill come over last night?
>>
>> You answer yes because Bill's lawyer came over and Bill's lawyer
>> represents Bill.
>>
>>
>
> Say what you will, but the DEFINTION of what a Halt Decider is supposed
> to answer on is the actual behavior of the machine that the input
> represents.
>
If the court is trying to establish an alibi for Bill and you answer
this on the basis that Bill's lawyer instead of Bill you would go to
prison for perjury. This proves that you are not allowed to use the term
"represents" to refer to something else somewhere else.


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

<i0UMJ.29891$Lbb6.12914@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer02.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.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<hU0MJ.10309$r6p7.7703@fx41.iad>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 428
Message-ID: <i0UMJ.29891$Lbb6.12914@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 13:48:45 -0500
X-Received-Bytes: 23800
 by: Richard Damon - Wed, 9 Feb 2022 18:48 UTC

On 2/9/22 1:39 PM, olcott wrote:
> On 2/9/2022 11:35 AM, Richard Damon wrote:
>> On 2/9/22 12:08 PM, olcott wrote:
>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously been
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> considered to be proof that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is undecidable. That is all that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be all knowing. To refute the proofs I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely need to show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider, must only go to H,Qn if the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input represents will never halt. They
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim youhave, but only that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> amassed an amazing pile of unsound logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on wrong definitions that have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> hoodwinked yourself into thinking you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong and
>>>>>>>>>>>>>>>>>>>>>>>>>>> never will because you believe that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory,
>>>>>>>>>>>>>>>>>>>>>>>>>> using Computation Theory Deffinitions, that is
>>>>>>>>>>>>>>>>>>>>>>>>>> your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input finite
>>>>>>>>>>>>>>>>>>>>>>>>>>> strings to an accept or reject state on the
>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of whether or not their correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input could ever reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>> state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem
>>>>>>>>>>>>>>>>>>>>>>>>>> of Computation Theory, BY DEFINITION, the
>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of 'correcty simulted' is simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> by a REAL UTM which BY DEFINITION exactly
>>>>>>>>>>>>>>>>>>>>>>>>>> matches the behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^> is H^
>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough
>>>>>>>>>>>>>>>>>>>>>>>>> steps for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to transition to ⟨Ĥ⟩.qn then the
>>>>>>>>>>>>>>>>>>>>>>>>> input to embedded_H meets the Linz definition
>>>>>>>>>>>>>>>>>>>>>>>>> of a sequence of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps
>>>>>>>>>>>>>>>>>>>>>>>> and doesn't reach a final state, then it shows
>>>>>>>>>>>>>>>>>>>>>>>> its input never halts.
>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in
>>>>>>>>>>>>>>>>>>>>>>> the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>> embedded_H will never reach ⟨Ĥ⟩.qn in any number
>>>>>>>>>>>>>>>>>>>>>>> of steps, which proves that this input cannot
>>>>>>>>>>>>>>>>>>>>>>> possibly meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that
>>>>>>>>>>>>>>>>>>>>>> does not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this
>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^ that
>>>>>>>>>>>>>>>>>>>> is using it will Halt,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the
>>>>>>>>>>>>>>>>>>> front. If someone comes in the back door (non-inputs)
>>>>>>>>>>>>>>>>>>> embedded_H is not even allowed to pay attention.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is not
>>>>>>>>>>>>>>>>>> the behavior of H^ applied to <H^> you are lying about
>>>>>>>>>>>>>>>>>> doing the Halting Problem.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>>>>> cannot possibly ever reach its final state of ⟨Ĥ⟩.qn,
>>>>>>>>>>>>>>>>> then nothing in the universe can possibly contradict
>>>>>>>>>>>>>>>>> the fact that the input specifies a non-halting
>>>>>>>>>>>>>>>>> sequences of configurations. If God himself said
>>>>>>>>>>>>>>>>> otherwise then God himself would be a liar.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and
>>>>>>>>>>>>>>>> goes to H.Qn, then the CORRECT simulation of its input
>>>>>>>>>>>>>>>> (that done by a REAL UTM) will show that it will go to
>>>>>>>>>>>>>>>> H^.Qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and thus
>>>>>>>>>>>>>>>> doesn't go to H.Qn, and thus fails to be a correct
>>>>>>>>>>>>>>>> decider, then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>>>>>> simulation is a 'correct' simulation. By the definition
>>>>>>>>>>>>>>>> in Computation Theory, this is not true. If you think it
>>>>>>>>>>>>>>>> is, it just proves that you don't understand the field.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know that
>>>>>>>>>>>>>>>>> we have a cat.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think you
>>>>>>>>>>>>>>>> do then you are wrong. If H aborts its simulation, it
>>>>>>>>>>>>>>>> isn't a UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If we know that we have a sequence of configurations
>>>>>>>>>>>>>>>>> that cannot possibly ever reach its final state then we
>>>>>>>>>>>>>>>>> know that we have a non-halting sequence of
>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then
>>>>>>>>>>>>>>>> the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^
>>>>>>>>>>>>>>>> will be non-halting, but H is still wrong for not
>>>>>>>>>>>>>>>> answering. If H does abort, then it hasn't proven
>>>>>>>>>>>>>>>> anything, and it has been proven that it is wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity to
>>>>>>>>>>>>> understand what I am saying. This is proven on the basis
>>>>>>>>>>>>> that what I am saying can be verified as true entirely on
>>>>>>>>>>>>> the basis of the meaning of its words.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that it has been shown that you keep on using the
>>>>>>>>>>>> WRONG definitions of the words.
>>>>>>>>>>>>
>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a UTM
>>>>>>>>>>>> EXACTLY repoduces the behavior of its input (so if it is
>>>>>>>>>>>> non-halting, so will the UTM). Also you think that there can
>>>>>>>>>>>> be a 'Correct Simulation' by something that is NOT actully a
>>>>>>>>>>>> UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> Care to show anywhere where your misdefinitions are support
>>>>>>>>>>>> in the field fo Computation Theory.
>>>>>>>>>>>>
>>>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>>>>>> because you just don't know the field, so don't have any
>>>>>>>>>>>>>> idea what is legal or not.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect, you
>>>>>>>>>>>>>> need to be able to explain it to someone who understands
>>>>>>>>>>>>>> Computation Theory, which is a fairly specialized branch
>>>>>>>>>>>>>> of Mathematics. Yes, it is part of the foundation of
>>>>>>>>>>>>>> Computer Science, but isn't the sort of thing that a
>>>>>>>>>>>>>> normal Computer Scientist will deal with day to day.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>>> meaning of what I am saying instead of mere rote memorized
>>>>>>>>>>>>> meanings from textbooks.
>>>>>>>>>>>>
>>>>>>>>>>>> No, you need to learn that words have PRECISE meanings, and
>>>>>>>>>>>> you aren't allowed to change them, no mwtter how much it
>>>>>>>>>>>> 'makes sense' to do so.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>>>>>> believe that the halt decider is supposed to evaluate its
>>>>>>>>>>>>> input on the basis of some proxy for the actual behavior of
>>>>>>>>>>>>> this actual input rather than the actual behavior specified
>>>>>>>>>>>>> by this actual input.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Just proves you aren't working on the Halting Problem, as
>>>>>>>>>>>> the DEFINITION of the Halting problems says that it is,
>>>>>>>>>>>> because you don't actually understand the meaning of 'actual
>>>>>>>>>>>> behavior'.
>>>>>>>>>>>>
>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will never
>>>>>>>>>>>> halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If you are supposed to report when Bill arrives at your house
>>>>>>>>>>> and Sam arrives at you house and you really really believe
>>>>>>>>>>> that Sam's arrival is a valid proxy for Bill's arrival then
>>>>>>>>>>> when I ask you did Bill arrive at your house? you say "yes"
>>>>>>>>>>> even though correct the answer is "no".
>>>>>>>>>>
>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>
>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied to
>>>>>>>>>> wM w is based on the behavior of M applied to w.
>>>>>>>>>>
>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>
>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>> only correct halt status criterion measure that might as well
>>>>>>>>> say that cats are not animals.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>>>> refuse to accept the definition because it doesn't match your
>>>>>>>> idea of what you need.
>>>>>>>>
>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>>>> defined, and it IS the behavior that the input specifes, The
>>>>>>>> input to the decider is the description of a computation, and
>>>>>>>> the actual behavior sepecified by the input is by defintion the
>>>>>>>> behavior of that computation that the input describes.
>>>>>>>>
>>>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>>>> specified by the input, but the behavior of the program that is
>>>>>>>> processing the input. YOUR definition of the behavior has the
>>>>>>>> problem that the behavior is no longer just specified by 'the
>>>>>>>> input' but is also a function of what program you give that
>>>>>>>> input to.
>>>>>>>>
>>>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>>>> your mind is.
>>>>>>>>
>>>>>>>> This statement of your just shows how you have lost touch with
>>>>>>>> the reality of the situation. You seem to think the Univese must
>>>>>>>> be wrong because it doesn't match your expectations. THAT is a
>>>>>>>> sign of mental illness.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will
>>>>>> Halt.
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>>>>> never Halt.
>>>>>>
>>>>>> you keep forgetting the conditions, which are important.
>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn
>>>>> without contradiction.
>>>>
>>>> Bing a pathological liar seems to have made you lose your sense of
>>>> what is true.
>>>>
>>>> While H^ applied to <H^> IS a different computation then H applied
>>>> to <H^> <H^> the former uses the latter to determine its behavior.
>>>>
>>>> The issue isn't a 'contradiction' between the behavior of the two
>>>> machines but the contradiction between the behavior of these two
>>>> machines and the concept that H is correct.
>>>>
>>>>>
>>>>> Like the guard that is only accountable for guarding the front door
>>>>> simulating halt decider embedded_H is only accountable for
>>>>> reporting whether or not its simulated input can possibly reach its
>>>>> own final state ⟨Ĥ⟩.qn.
>>>>
>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>
>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>> ACTUAL MACHINE the input represents.
>>>
>>> You have this misconception welded into your brain.
>>> That is just like asking did Bill come over last night?
>>>
>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>> represents Bill.
>>>
>>>
>>
>> Say what you will, but the DEFINTION of what a Halt Decider is
>> supposed to answer on is the actual behavior of the machine that the
>> input represents.
>>
> If the court is trying to establish an alibi for Bill and you answer
> this on the basis that Bill's lawyer instead of Bill you would go to
> prison for perjury. This proves that you are not allowed to use the term
> "represents" to refer to something else somewhere else.


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

<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 18:55:39 +0000
Date: Wed, 9 Feb 2022 12:56:08 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<suidnekM1sLLPZ3_nZ2dnUU7-LfNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <i0UMJ.29891$Lbb6.12914@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
Lines: 433
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-khC7apQVKGvaNI2T5pXX955WLzYXo5okyq8suklRPmve6WNIO7nbVAAsM2xS3KG5fBQoIm0HRGWIogk!euye4ZQj4yl8V7WbW9hj+cygmAikxegwy6Wgt4WYsPpw+qLcbdx9h+PwxslcbK6EbNmHN4S3TenM
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: 24802
 by: olcott - Wed, 9 Feb 2022 18:56 UTC

On 2/9/2022 12:48 PM, Richard Damon wrote:
>
> On 2/9/22 1:39 PM, olcott wrote:
>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>> On 2/9/22 12:08 PM, olcott wrote:
>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been considered to be proof that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is undecidable. That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be all knowing. To refute the proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I merely need to show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider, must only go to H,Qn if the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine its input represents will never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. They you also don't seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand that the computaton that <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> represents IS H^ applied to <H^>. So,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim youhave, but only that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> amassed an amazing pile of unsound logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on wrong definitions that have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hoodwinked yourself into thinking you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gaslighted yourself so you can't actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never will because you believe that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory,
>>>>>>>>>>>>>>>>>>>>>>>>>>> using Computation Theory Deffinitions, that
>>>>>>>>>>>>>>>>>>>>>>>>>>> is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings to an accept or reject state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of whether or not their
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input could ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting Problem
>>>>>>>>>>>>>>>>>>>>>>>>>>> of Computation Theory, BY DEFINITION, the
>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of 'correcty simulted' is simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> by a REAL UTM which BY DEFINITION exactly
>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the behavior of Computation that it
>>>>>>>>>>>>>>>>>>>>>>>>>>> is representation of, which for <H^> <H^> is
>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough
>>>>>>>>>>>>>>>>>>>>>>>>>> steps for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to transition to ⟨Ĥ⟩.qn then the
>>>>>>>>>>>>>>>>>>>>>>>>>> input to embedded_H meets the Linz definition
>>>>>>>>>>>>>>>>>>>>>>>>>> of a sequence of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps
>>>>>>>>>>>>>>>>>>>>>>>>> and doesn't reach a final state, then it shows
>>>>>>>>>>>>>>>>>>>>>>>>> its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern in
>>>>>>>>>>>>>>>>>>>>>>>> the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> by embedded_H will never reach ⟨Ĥ⟩.qn in any
>>>>>>>>>>>>>>>>>>>>>>>> number of steps, which proves that this input
>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly meet the Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>> halting:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine will
>>>>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that
>>>>>>>>>>>>>>>>>>>>>>> does not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this
>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^
>>>>>>>>>>>>>>>>>>>>> that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the
>>>>>>>>>>>>>>>>>>>> front. If someone comes in the back door
>>>>>>>>>>>>>>>>>>>> (non-inputs) embedded_H is not even allowed to pay
>>>>>>>>>>>>>>>>>>>> attention.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is
>>>>>>>>>>>>>>>>>>> not the behavior of H^ applied to <H^> you are lying
>>>>>>>>>>>>>>>>>>> about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>> cannot possibly ever reach its final state of ⟨Ĥ⟩.qn,
>>>>>>>>>>>>>>>>>> then nothing in the universe can possibly contradict
>>>>>>>>>>>>>>>>>> the fact that the input specifies a non-halting
>>>>>>>>>>>>>>>>>> sequences of configurations. If God himself said
>>>>>>>>>>>>>>>>>> otherwise then God himself would be a liar.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and
>>>>>>>>>>>>>>>>> goes to H.Qn, then the CORRECT simulation of its input
>>>>>>>>>>>>>>>>> (that done by a REAL UTM) will show that it will go to
>>>>>>>>>>>>>>>>> H^.Qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and
>>>>>>>>>>>>>>>>> thus doesn't go to H.Qn, and thus fails to be a correct
>>>>>>>>>>>>>>>>> decider, then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>>>>>>> simulation is a 'correct' simulation. By the definition
>>>>>>>>>>>>>>>>> in Computation Theory, this is not true. If you think
>>>>>>>>>>>>>>>>> it is, it just proves that you don't understand the field.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know that
>>>>>>>>>>>>>>>>>> we have a cat.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think you
>>>>>>>>>>>>>>>>> do then you are wrong. If H aborts its simulation, it
>>>>>>>>>>>>>>>>> isn't a UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If we know that we have a sequence of configurations
>>>>>>>>>>>>>>>>>> that cannot possibly ever reach its final state then
>>>>>>>>>>>>>>>>>> we know that we have a non-halting sequence of
>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then
>>>>>>>>>>>>>>>>> the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves just
>>>>>>>>>>>>>>>>> proves that if H is a UTM, which don't abort, then H^
>>>>>>>>>>>>>>>>> will be non-halting, but H is still wrong for not
>>>>>>>>>>>>>>>>> answering. If H does abort, then it hasn't proven
>>>>>>>>>>>>>>>>> anything, and it has been proven that it is wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity
>>>>>>>>>>>>>> to understand what I am saying. This is proven on the
>>>>>>>>>>>>>> basis that what I am saying can be verified as true
>>>>>>>>>>>>>> entirely on the basis of the meaning of its words.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that it has been shown that you keep on using the
>>>>>>>>>>>>> WRONG definitions of the words.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a
>>>>>>>>>>>>> UTM EXACTLY repoduces the behavior of its input (so if it
>>>>>>>>>>>>> is non-halting, so will the UTM). Also you think that there
>>>>>>>>>>>>> can be a 'Correct Simulation' by something that is NOT
>>>>>>>>>>>>> actully a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are support
>>>>>>>>>>>>> in the field fo Computation Theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>>>>>>> because you just don't know the field, so don't have any
>>>>>>>>>>>>>>> idea what is legal or not.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect, you
>>>>>>>>>>>>>>> need to be able to explain it to someone who understands
>>>>>>>>>>>>>>> Computation Theory, which is a fairly specialized branch
>>>>>>>>>>>>>>> of Mathematics. Yes, it is part of the foundation of
>>>>>>>>>>>>>>> Computer Science, but isn't the sort of thing that a
>>>>>>>>>>>>>>> normal Computer Scientist will deal with day to day.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>>>> meaning of what I am saying instead of mere rote memorized
>>>>>>>>>>>>>> meanings from textbooks.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, you need to learn that words have PRECISE meanings, and
>>>>>>>>>>>>> you aren't allowed to change them, no mwtter how much it
>>>>>>>>>>>>> 'makes sense' to do so.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>>>>>>> believe that the halt decider is supposed to evaluate its
>>>>>>>>>>>>>> input on the basis of some proxy for the actual behavior
>>>>>>>>>>>>>> of this actual input rather than the actual behavior
>>>>>>>>>>>>>> specified by this actual input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just proves you aren't working on the Halting Problem, as
>>>>>>>>>>>>> the DEFINITION of the Halting problems says that it is,
>>>>>>>>>>>>> because you don't actually understand the meaning of
>>>>>>>>>>>>> 'actual behavior'.
>>>>>>>>>>>>>
>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will
>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If you are supposed to report when Bill arrives at your
>>>>>>>>>>>> house and Sam arrives at you house and you really really
>>>>>>>>>>>> believe that Sam's arrival is a valid proxy for Bill's
>>>>>>>>>>>> arrival then when I ask you did Bill arrive at your house?
>>>>>>>>>>>> you say "yes" even though correct the answer is "no".
>>>>>>>>>>>
>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>
>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied
>>>>>>>>>>> to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>
>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>
>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>>> only correct halt status criterion measure that might as well
>>>>>>>>>> say that cats are not animals.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>>>>> refuse to accept the definition because it doesn't match your
>>>>>>>>> idea of what you need.
>>>>>>>>>
>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>>>>> defined, and it IS the behavior that the input specifes, The
>>>>>>>>> input to the decider is the description of a computation, and
>>>>>>>>> the actual behavior sepecified by the input is by defintion the
>>>>>>>>> behavior of that computation that the input describes.
>>>>>>>>>
>>>>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>>>>> specified by the input, but the behavior of the program that is
>>>>>>>>> processing the input. YOUR definition of the behavior has the
>>>>>>>>> problem that the behavior is no longer just specified by 'the
>>>>>>>>> input' but is also a function of what program you give that
>>>>>>>>> input to.
>>>>>>>>>
>>>>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>>>>> your mind is.
>>>>>>>>>
>>>>>>>>> This statement of your just shows how you have lost touch with
>>>>>>>>> the reality of the situation. You seem to think the Univese
>>>>>>>>> must be wrong because it doesn't match your expectations. THAT
>>>>>>>>> is a sign of mental illness.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^> Will
>>>>>>> Halt.
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^> will
>>>>>>> never Halt.
>>>>>>>
>>>>>>> you keep forgetting the conditions, which are important.
>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn
>>>>>> without contradiction.
>>>>>
>>>>> Bing a pathological liar seems to have made you lose your sense of
>>>>> what is true.
>>>>>
>>>>> While H^ applied to <H^> IS a different computation then H applied
>>>>> to <H^> <H^> the former uses the latter to determine its behavior.
>>>>>
>>>>> The issue isn't a 'contradiction' between the behavior of the two
>>>>> machines but the contradiction between the behavior of these two
>>>>> machines and the concept that H is correct.
>>>>>
>>>>>>
>>>>>> Like the guard that is only accountable for guarding the front
>>>>>> door simulating halt decider embedded_H is only accountable for
>>>>>> reporting whether or not its simulated input can possibly reach
>>>>>> its own final state ⟨Ĥ⟩.qn.
>>>>>
>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>
>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>>> ACTUAL MACHINE the input represents.
>>>>
>>>> You have this misconception welded into your brain.
>>>> That is just like asking did Bill come over last night?
>>>>
>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>> represents Bill.
>>>>
>>>>
>>>
>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>> supposed to answer on is the actual behavior of the machine that the
>>> input represents.
>>>
>> If the court is trying to establish an alibi for Bill and you answer
>> this on the basis that Bill's lawyer instead of Bill you would go to
>> prison for perjury. This proves that you are not allowed to use the
>> term "represents" to refer to something else somewhere else.
>
> So, do you think you should go to jail for the perjury of Ha reporting
> on the behavior of Hn^ instead if Ha^?
>
> That is your wrong answer.
>>
>> When a finite string Turing machine description represents a Turing
>> Machine then the UTM simulation of the finite string will always have
>> computationally equivalent behavior to the direct execution of the
>> Turing machine.
>
> Right, A REAL UTM, which never aborts its simulation, but is non-halting
> if its input represents a non-halting computation, as is part of the
> defintion of a UTM.


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

<stUMJ.47863$t2Bb.14394@fx98.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<AF7MJ.13063$ZmJ7.6019@fx06.iad>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 478
Message-ID: <stUMJ.47863$t2Bb.14394@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 14:19:52 -0500
X-Received-Bytes: 26754
 by: Richard Damon - Wed, 9 Feb 2022 19:19 UTC

On 2/9/22 1:56 PM, olcott wrote:
> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>
>> On 2/9/22 1:39 PM, olcott wrote:
>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been considered to be proof that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is undecidable. That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be all knowing. To refute the proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I merely need to show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction H^ <H^> goes to H^.Qn, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and since H, to be an accurate Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider, must only go to H,Qn if the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine its input represents will never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. They you also don't seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand that the computaton that <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> represents IS H^ applied to <H^>. So,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim youhave, but only that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> amassed an amazing pile of unsound logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on wrong definitions that have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hoodwinked yourself into thinking you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have gaslighted yourself so you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and never will because you believe that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation Theory,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> using Computation Theory Deffinitions, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings to an accept or reject state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of whether or not their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input could ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM which
>>>>>>>>>>>>>>>>>>>>>>>>>>>> BY DEFINITION exactly matches the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Computation that it is representation of,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough
>>>>>>>>>>>>>>>>>>>>>>>>>>> steps for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> by embedded_H to transition to ⟨Ĥ⟩.qn then
>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to embedded_H meets the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>> that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of steps
>>>>>>>>>>>>>>>>>>>>>>>>>> and doesn't reach a final state, then it shows
>>>>>>>>>>>>>>>>>>>>>>>>>> its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern
>>>>>>>>>>>>>>>>>>>>>>>>> in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> by embedded_H will never reach ⟨Ĥ⟩.qn in any
>>>>>>>>>>>>>>>>>>>>>>>>> number of steps, which proves that this input
>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly meet the Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>>> halting:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that
>>>>>>>>>>>>>>>>>>>>>>>> does not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this
>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^
>>>>>>>>>>>>>>>>>>>>>> that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of its
>>>>>>>>>>>>>>>>>>>>> inputs as if its was a guard assigned to watch the
>>>>>>>>>>>>>>>>>>>>> front. If someone comes in the back door
>>>>>>>>>>>>>>>>>>>>> (non-inputs) embedded_H is not even allowed to pay
>>>>>>>>>>>>>>>>>>>>> attention.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is
>>>>>>>>>>>>>>>>>>>> not the behavior of H^ applied to <H^> you are lying
>>>>>>>>>>>>>>>>>>>> about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>> cannot possibly ever reach its final state of ⟨Ĥ⟩.qn,
>>>>>>>>>>>>>>>>>>> then nothing in the universe can possibly contradict
>>>>>>>>>>>>>>>>>>> the fact that the input specifies a non-halting
>>>>>>>>>>>>>>>>>>> sequences of configurations. If God himself said
>>>>>>>>>>>>>>>>>>> otherwise then God himself would be a liar.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and
>>>>>>>>>>>>>>>>>> goes to H.Qn, then the CORRECT simulation of its input
>>>>>>>>>>>>>>>>>> (that done by a REAL UTM) will show that it will go to
>>>>>>>>>>>>>>>>>> H^.Qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and
>>>>>>>>>>>>>>>>>> thus doesn't go to H.Qn, and thus fails to be a
>>>>>>>>>>>>>>>>>> correct decider, then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts its
>>>>>>>>>>>>>>>>>> simulation is a 'correct' simulation. By the
>>>>>>>>>>>>>>>>>> definition in Computation Theory, this is not true. If
>>>>>>>>>>>>>>>>>> you think it is, it just proves that you don't
>>>>>>>>>>>>>>>>>> understand the field.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know that
>>>>>>>>>>>>>>>>>>> we have a cat.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think
>>>>>>>>>>>>>>>>>> you do then you are wrong. If H aborts its simulation,
>>>>>>>>>>>>>>>>>> it isn't a UTM and doesn't 'correctly' simulate.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of configurations
>>>>>>>>>>>>>>>>>>> that cannot possibly ever reach its final state then
>>>>>>>>>>>>>>>>>>> we know that we have a non-halting sequence of
>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then
>>>>>>>>>>>>>>>>>> the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves
>>>>>>>>>>>>>>>>>> just proves that if H is a UTM, which don't abort,
>>>>>>>>>>>>>>>>>> then H^ will be non-halting, but H is still wrong for
>>>>>>>>>>>>>>>>>> not answering. If H does abort, then it hasn't proven
>>>>>>>>>>>>>>>>>> anything, and it has been proven that it is wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are either not bright enough to get this or dishonest.
>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity
>>>>>>>>>>>>>>> to understand what I am saying. This is proven on the
>>>>>>>>>>>>>>> basis that what I am saying can be verified as true
>>>>>>>>>>>>>>> entirely on the basis of the meaning of its words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that it has been shown that you keep on using the
>>>>>>>>>>>>>> WRONG definitions of the words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a
>>>>>>>>>>>>>> UTM EXACTLY repoduces the behavior of its input (so if it
>>>>>>>>>>>>>> is non-halting, so will the UTM). Also you think that
>>>>>>>>>>>>>> there can be a 'Correct Simulation' by something that is
>>>>>>>>>>>>>> NOT actully a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions, maybe
>>>>>>>>>>>>>>>> because you just don't know the field, so don't have any
>>>>>>>>>>>>>>>> idea what is legal or not.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect, you
>>>>>>>>>>>>>>>> need to be able to explain it to someone who understands
>>>>>>>>>>>>>>>> Computation Theory, which is a fairly specialized branch
>>>>>>>>>>>>>>>> of Mathematics. Yes, it is part of the foundation of
>>>>>>>>>>>>>>>> Computer Science, but isn't the sort of thing that a
>>>>>>>>>>>>>>>> normal Computer Scientist will deal with day to day.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>>>>> meaning of what I am saying instead of mere rote
>>>>>>>>>>>>>>> memorized meanings from textbooks.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, you need to learn that words have PRECISE meanings,
>>>>>>>>>>>>>> and you aren't allowed to change them, no mwtter how much
>>>>>>>>>>>>>> it 'makes sense' to do so.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key mistake that my reviewers are making is that they
>>>>>>>>>>>>>>> believe that the halt decider is supposed to evaluate its
>>>>>>>>>>>>>>> input on the basis of some proxy for the actual behavior
>>>>>>>>>>>>>>> of this actual input rather than the actual behavior
>>>>>>>>>>>>>>> specified by this actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just proves you aren't working on the Halting Problem, as
>>>>>>>>>>>>>> the DEFINITION of the Halting problems says that it is,
>>>>>>>>>>>>>> because you don't actually understand the meaning of
>>>>>>>>>>>>>> 'actual behavior'.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will
>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you are supposed to report when Bill arrives at your
>>>>>>>>>>>>> house and Sam arrives at you house and you really really
>>>>>>>>>>>>> believe that Sam's arrival is a valid proxy for Bill's
>>>>>>>>>>>>> arrival then when I ask you did Bill arrive at your house?
>>>>>>>>>>>>> you say "yes" even though correct the answer is "no".
>>>>>>>>>>>>
>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>
>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied
>>>>>>>>>>>> to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>>
>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>
>>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>>>> only correct halt status criterion measure that might as well
>>>>>>>>>>> say that cats are not animals.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You just
>>>>>>>>>> refuse to accept the definition because it doesn't match your
>>>>>>>>>> idea of what you need.
>>>>>>>>>>
>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS precisly
>>>>>>>>>> defined, and it IS the behavior that the input specifes, The
>>>>>>>>>> input to the decider is the description of a computation, and
>>>>>>>>>> the actual behavior sepecified by the input is by defintion
>>>>>>>>>> the behavior of that computation that the input describes.
>>>>>>>>>>
>>>>>>>>>> YOU are the one that wants to change it to not be the behavior
>>>>>>>>>> specified by the input, but the behavior of the program that
>>>>>>>>>> is processing the input. YOUR definition of the behavior has
>>>>>>>>>> the problem that the behavior is no longer just specified by
>>>>>>>>>> 'the input' but is also a function of what program you give
>>>>>>>>>> that input to.
>>>>>>>>>>
>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how sound
>>>>>>>>>> your mind is.
>>>>>>>>>>
>>>>>>>>>> This statement of your just shows how you have lost touch with
>>>>>>>>>> the reality of the situation. You seem to think the Univese
>>>>>>>>>> must be wrong because it doesn't match your expectations. THAT
>>>>>>>>>> is a sign of mental illness.
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^>
>>>>>>>> Will Halt.
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^>
>>>>>>>> will never Halt.
>>>>>>>>
>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to Ĥ.qn
>>>>>>> without contradiction.
>>>>>>
>>>>>> Bing a pathological liar seems to have made you lose your sense of
>>>>>> what is true.
>>>>>>
>>>>>> While H^ applied to <H^> IS a different computation then H applied
>>>>>> to <H^> <H^> the former uses the latter to determine its behavior.
>>>>>>
>>>>>> The issue isn't a 'contradiction' between the behavior of the two
>>>>>> machines but the contradiction between the behavior of these two
>>>>>> machines and the concept that H is correct.
>>>>>>
>>>>>>>
>>>>>>> Like the guard that is only accountable for guarding the front
>>>>>>> door simulating halt decider embedded_H is only accountable for
>>>>>>> reporting whether or not its simulated input can possibly reach
>>>>>>> its own final state ⟨Ĥ⟩.qn.
>>>>>>
>>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>>
>>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>>>> ACTUAL MACHINE the input represents.
>>>>>
>>>>> You have this misconception welded into your brain.
>>>>> That is just like asking did Bill come over last night?
>>>>>
>>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>>> represents Bill.
>>>>>
>>>>>
>>>>
>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>> supposed to answer on is the actual behavior of the machine that the
>>>> input represents.
>>>>
>>> If the court is trying to establish an alibi for Bill and you answer
>>> this on the basis that Bill's lawyer instead of Bill you would go to
>>> prison for perjury. This proves that you are not allowed to use the
>>> term "represents" to refer to something else somewhere else.
>>
>> So, do you think you should go to jail for the perjury of Ha reporting
>> on the behavior of Hn^ instead if Ha^?
>>
>> That is your wrong answer.
>>>
>>> When a finite string Turing machine description represents a Turing
>>> Machine then the UTM simulation of the finite string will always have
>>> computationally equivalent behavior to the direct execution of the
>>> Turing machine.
>>
>> Right, A REAL UTM, which never aborts its simulation, but is
>> non-halting if its input represents a non-halting computation, as is
>> part of the defintion of a UTM.
>
> When embedded_H correctly determines that the pure simulation of its
> input by a real UTM would never reach the final state of this input and
> it makes this determination in a finite number of steps, then it is
> necessarily correct for embedded_H  to transition to its reject state.
>


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

<su156n$292$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Followup-To: comp.theory
Date: Wed, 9 Feb 2022 13:37:57 -0600
Organization: A noiseless patient Spider
Lines: 451
Message-ID: <su156n$292$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<xNmdnQ0SX4BKrpz_nZ2dnUU7-S3NnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 9 Feb 2022 19:37:59 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="52880b110edbd35d3ee01e686669fd61";
logging-data="2338"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18P8pMUQ6QEz1F4FKJ/Slrr"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Cancel-Lock: sha1:Vq3vXB1xjodZiNVLqAH9foaC1QU=
In-Reply-To: <stUMJ.47863$t2Bb.14394@fx98.iad>
Content-Language: en-US
 by: olcott - Wed, 9 Feb 2022 19:37 UTC

On 2/9/2022 1:19 PM, Richard Damon wrote:
> On 2/9/22 1:56 PM, olcott wrote:
>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>
>>> On 2/9/22 1:39 PM, olcott wrote:
>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been considered to be proof that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is undecidable. That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be all knowing. To refute the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs I merely need to show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be proved to never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by construction H^ <H^> goes to H^.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and halts, and since H, to be an accurate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt Decider, must only go to H,Qn if the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine its input represents will never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt. They you also don't seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand that the computaton that <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> represents IS H^ applied to <H^>.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim youhave, but only that you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> amassed an amazing pile of unsound logic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on wrong definitions that have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hoodwinked yourself into thinking you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have gaslighted yourself so you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and never will because you believe that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory, using Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of whether or not their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input could ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BY DEFINITION exactly matches the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Computation that it is representation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of, which for <H^> <H^> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps for the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>> by embedded_H to transition to ⟨Ĥ⟩.qn then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to embedded_H meets the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a sequence of configurations
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>> steps and doesn't reach a final state, then
>>>>>>>>>>>>>>>>>>>>>>>>>>> it shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern
>>>>>>>>>>>>>>>>>>>>>>>>>> in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> by embedded_H will never reach ⟨Ĥ⟩.qn in any
>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps, which proves that this input
>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly meet the Linz definition of
>>>>>>>>>>>>>>>>>>>>>>>>>> halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show that
>>>>>>>>>>>>>>>>>>>>>>>>> does not halt is H, so H can not be a decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match this
>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^
>>>>>>>>>>>>>>>>>>>>>>> that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of
>>>>>>>>>>>>>>>>>>>>>> its inputs as if its was a guard assigned to watch
>>>>>>>>>>>>>>>>>>>>>> the front. If someone comes in the back door
>>>>>>>>>>>>>>>>>>>>>> (non-inputs) embedded_H is not even allowed to pay
>>>>>>>>>>>>>>>>>>>>>> attention.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is
>>>>>>>>>>>>>>>>>>>>> not the behavior of H^ applied to <H^> you are
>>>>>>>>>>>>>>>>>>>>> lying about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>> cannot possibly ever reach its final state of
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn, then nothing in the universe can possibly
>>>>>>>>>>>>>>>>>>>> contradict the fact that the input specifies a
>>>>>>>>>>>>>>>>>>>> non-halting sequences of configurations. If God
>>>>>>>>>>>>>>>>>>>> himself said otherwise then God himself would be a
>>>>>>>>>>>>>>>>>>>> liar.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation and
>>>>>>>>>>>>>>>>>>> goes to H.Qn, then the CORRECT simulation of its
>>>>>>>>>>>>>>>>>>> input (that done by a REAL UTM) will show that it
>>>>>>>>>>>>>>>>>>> will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and
>>>>>>>>>>>>>>>>>>> thus doesn't go to H.Qn, and thus fails to be a
>>>>>>>>>>>>>>>>>>> correct decider, then H^ applied to <H^> is non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts
>>>>>>>>>>>>>>>>>>> its simulation is a 'correct' simulation. By the
>>>>>>>>>>>>>>>>>>> definition in Computation Theory, this is not true.
>>>>>>>>>>>>>>>>>>> If you think it is, it just proves that you don't
>>>>>>>>>>>>>>>>>>> understand the field.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know
>>>>>>>>>>>>>>>>>>>> that we have a cat.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think
>>>>>>>>>>>>>>>>>>> you do then you are wrong. If H aborts its
>>>>>>>>>>>>>>>>>>> simulation, it isn't a UTM and doesn't 'correctly'
>>>>>>>>>>>>>>>>>>> simulate.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of configurations
>>>>>>>>>>>>>>>>>>>> that cannot possibly ever reach its final state then
>>>>>>>>>>>>>>>>>>>> we know that we have a non-halting sequence of
>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn then
>>>>>>>>>>>>>>>>>>> the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves
>>>>>>>>>>>>>>>>>>> just proves that if H is a UTM, which don't abort,
>>>>>>>>>>>>>>>>>>> then H^ will be non-halting, but H is still wrong for
>>>>>>>>>>>>>>>>>>> not answering. If H does abort, then it hasn't proven
>>>>>>>>>>>>>>>>>>> anything, and it has been proven that it is wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are either not bright enough to get this or
>>>>>>>>>>>>>>>>>> dishonest.
>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual capacity
>>>>>>>>>>>>>>>> to understand what I am saying. This is proven on the
>>>>>>>>>>>>>>>> basis that what I am saying can be verified as true
>>>>>>>>>>>>>>>> entirely on the basis of the meaning of its words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that it has been shown that you keep on using the
>>>>>>>>>>>>>>> WRONG definitions of the words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a
>>>>>>>>>>>>>>> UTM EXACTLY repoduces the behavior of its input (so if it
>>>>>>>>>>>>>>> is non-halting, so will the UTM). Also you think that
>>>>>>>>>>>>>>> there can be a 'Correct Simulation' by something that is
>>>>>>>>>>>>>>> NOT actully a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions,
>>>>>>>>>>>>>>>>> maybe because you just don't know the field, so don't
>>>>>>>>>>>>>>>>> have any idea what is legal or not.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect,
>>>>>>>>>>>>>>>>> you need to be able to explain it to someone who
>>>>>>>>>>>>>>>>> understands Computation Theory, which is a fairly
>>>>>>>>>>>>>>>>> specialized branch of Mathematics. Yes, it is part of
>>>>>>>>>>>>>>>>> the foundation of Computer Science, but isn't the sort
>>>>>>>>>>>>>>>>> of thing that a normal Computer Scientist will deal
>>>>>>>>>>>>>>>>> with day to day.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>>>>>> meaning of what I am saying instead of mere rote
>>>>>>>>>>>>>>>> memorized meanings from textbooks.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, you need to learn that words have PRECISE meanings,
>>>>>>>>>>>>>>> and you aren't allowed to change them, no mwtter how much
>>>>>>>>>>>>>>> it 'makes sense' to do so.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The key mistake that my reviewers are making is that
>>>>>>>>>>>>>>>> they believe that the halt decider is supposed to
>>>>>>>>>>>>>>>> evaluate its input on the basis of some proxy for the
>>>>>>>>>>>>>>>> actual behavior of this actual input rather than the
>>>>>>>>>>>>>>>> actual behavior specified by this actual input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just proves you aren't working on the Halting Problem, as
>>>>>>>>>>>>>>> the DEFINITION of the Halting problems says that it is,
>>>>>>>>>>>>>>> because you don't actually understand the meaning of
>>>>>>>>>>>>>>> 'actual behavior'.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will
>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you are supposed to report when Bill arrives at your
>>>>>>>>>>>>>> house and Sam arrives at you house and you really really
>>>>>>>>>>>>>> believe that Sam's arrival is a valid proxy for Bill's
>>>>>>>>>>>>>> arrival then when I ask you did Bill arrive at your house?
>>>>>>>>>>>>>> you say "yes" even though correct the answer is "no".
>>>>>>>>>>>>>
>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>
>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H applied
>>>>>>>>>>>>> to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>
>>>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>>>>> only correct halt status criterion measure that might as
>>>>>>>>>>>> well say that cats are not animals.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You
>>>>>>>>>>> just refuse to accept the definition because it doesn't match
>>>>>>>>>>> your idea of what you need.
>>>>>>>>>>>
>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>> specifes, The input to the decider is the description of a
>>>>>>>>>>> computation, and the actual behavior sepecified by the input
>>>>>>>>>>> is by defintion the behavior of that computation that the
>>>>>>>>>>> input describes.
>>>>>>>>>>>
>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>> program that is processing the input. YOUR definition of the
>>>>>>>>>>> behavior has the problem that the behavior is no longer just
>>>>>>>>>>> specified by 'the input' but is also a function of what
>>>>>>>>>>> program you give that input to.
>>>>>>>>>>>
>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>
>>>>>>>>>>> This statement of your just shows how you have lost touch
>>>>>>>>>>> with the reality of the situation. You seem to think the
>>>>>>>>>>> Univese must be wrong because it doesn't match your
>>>>>>>>>>> expectations. THAT is a sign of mental illness.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^>
>>>>>>>>> Will Halt.
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^>
>>>>>>>>> will never Halt.
>>>>>>>>>
>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to
>>>>>>>> Ĥ.qn without contradiction.
>>>>>>>
>>>>>>> Bing a pathological liar seems to have made you lose your sense
>>>>>>> of what is true.
>>>>>>>
>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>> applied to <H^> <H^> the former uses the latter to determine its
>>>>>>> behavior.
>>>>>>>
>>>>>>> The issue isn't a 'contradiction' between the behavior of the two
>>>>>>> machines but the contradiction between the behavior of these two
>>>>>>> machines and the concept that H is correct.
>>>>>>>
>>>>>>>>
>>>>>>>> Like the guard that is only accountable for guarding the front
>>>>>>>> door simulating halt decider embedded_H is only accountable for
>>>>>>>> reporting whether or not its simulated input can possibly reach
>>>>>>>> its own final state ⟨Ĥ⟩.qn.
>>>>>>>
>>>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>>>
>>>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>>>>> ACTUAL MACHINE the input represents.
>>>>>>
>>>>>> You have this misconception welded into your brain.
>>>>>> That is just like asking did Bill come over last night?
>>>>>>
>>>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>>>> represents Bill.
>>>>>>
>>>>>>
>>>>>
>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>> supposed to answer on is the actual behavior of the machine that
>>>>> the input represents.
>>>>>
>>>> If the court is trying to establish an alibi for Bill and you answer
>>>> this on the basis that Bill's lawyer instead of Bill you would go to
>>>> prison for perjury. This proves that you are not allowed to use the
>>>> term "represents" to refer to something else somewhere else.
>>>
>>> So, do you think you should go to jail for the perjury of Ha
>>> reporting on the behavior of Hn^ instead if Ha^?
>>>
>>> That is your wrong answer.
>>>>
>>>> When a finite string Turing machine description represents a Turing
>>>> Machine then the UTM simulation of the finite string will always
>>>> have computationally equivalent behavior to the direct execution of
>>>> the Turing machine.
>>>
>>> Right, A REAL UTM, which never aborts its simulation, but is
>>> non-halting if its input represents a non-halting computation, as is
>>> part of the defintion of a UTM.
>>
>> When embedded_H correctly determines that the pure simulation of its
>> input by a real UTM would never reach the final state of this input
>> and it makes this determination in a finite number of steps, then it
>> is necessarily correct for embedded_H  to transition to its reject state.
>>
>
> Except that the 'correct determination' was based on the assumption that
> H/embedded_H IS just a UTM,


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

<OeVMJ.11688$V7da.9533@fx13.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<9biMJ.10134$Wdl5.2747@fx44.iad>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <su156n$292$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 486
Message-ID: <OeVMJ.11688$V7da.9533@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 15:12:29 -0500
X-Received-Bytes: 27616
 by: Richard Damon - Wed, 9 Feb 2022 20:12 UTC

On 2/9/22 2:37 PM, olcott wrote:
> On 2/9/2022 1:19 PM, Richard Damon wrote:
>> On 2/9/22 1:56 PM, olcott wrote:
>>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>>
>>>> On 2/9/22 1:39 PM, olcott wrote:
>>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM, dklei...@gmail.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at 8:31:41
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been considered to be proof that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is undecidable. That is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all that I need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be all knowing. To refute the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs I merely need to show that their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter-example can be proved to never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by construction H^ <H^> goes to H^.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and halts, and since H, to be an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accurate Halt Decider, must only go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H,Qn if the machine its input represents
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never halt. They you also don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to understand that the computaton
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that <H^> <H^> represents IS H^ applied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing you claim youhave, but only that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have amassed an amazing pile of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound logic based on wrong definitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that have hoodwinked yourself into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thinking you have shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have gaslighted yourself so you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and never will because you believe that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory, using Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their correctly simulated input could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough steps for the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Linz definition of a sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps and doesn't reach a final state, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> it shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>> in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H will never reach ⟨Ĥ⟩.qn in
>>>>>>>>>>>>>>>>>>>>>>>>>>> any number of steps, which proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly meet the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show
>>>>>>>>>>>>>>>>>>>>>>>>>> that does not halt is H, so H can not be a
>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates three
>>>>>>>>>>>>>>>>>>>>>>>>> iterations of nested simulation to match the
>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match
>>>>>>>>>>>>>>>>>>>>>>>>> this pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^
>>>>>>>>>>>>>>>>>>>>>>>> that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>> its inputs as if its was a guard assigned to
>>>>>>>>>>>>>>>>>>>>>>> watch the front. If someone comes in the back
>>>>>>>>>>>>>>>>>>>>>>> door (non-inputs) embedded_H is not even allowed
>>>>>>>>>>>>>>>>>>>>>>> to pay attention.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^> is
>>>>>>>>>>>>>>>>>>>>>> not the behavior of H^ applied to <H^> you are
>>>>>>>>>>>>>>>>>>>>>> lying about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to
>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn, then nothing in the universe can
>>>>>>>>>>>>>>>>>>>>> possibly contradict the fact that the input
>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequences of
>>>>>>>>>>>>>>>>>>>>> configurations. If God himself said otherwise then
>>>>>>>>>>>>>>>>>>>>> God himself would be a liar.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation
>>>>>>>>>>>>>>>>>>>> and goes to H.Qn, then the CORRECT simulation of its
>>>>>>>>>>>>>>>>>>>> input (that done by a REAL UTM) will show that it
>>>>>>>>>>>>>>>>>>>> will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and
>>>>>>>>>>>>>>>>>>>> thus doesn't go to H.Qn, and thus fails to be a
>>>>>>>>>>>>>>>>>>>> correct decider, then H^ applied to <H^> is
>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts
>>>>>>>>>>>>>>>>>>>> its simulation is a 'correct' simulation. By the
>>>>>>>>>>>>>>>>>>>> definition in Computation Theory, this is not true.
>>>>>>>>>>>>>>>>>>>> If you think it is, it just proves that you don't
>>>>>>>>>>>>>>>>>>>> understand the field.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know
>>>>>>>>>>>>>>>>>>>>> that we have a cat.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think
>>>>>>>>>>>>>>>>>>>> you do then you are wrong. If H aborts its
>>>>>>>>>>>>>>>>>>>> simulation, it isn't a UTM and doesn't 'correctly'
>>>>>>>>>>>>>>>>>>>> simulate.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of
>>>>>>>>>>>>>>>>>>>>> configurations that cannot possibly ever reach its
>>>>>>>>>>>>>>>>>>>>> final state then we know that we have a non-halting
>>>>>>>>>>>>>>>>>>>>> sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn
>>>>>>>>>>>>>>>>>>>> then the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves
>>>>>>>>>>>>>>>>>>>> just proves that if H is a UTM, which don't abort,
>>>>>>>>>>>>>>>>>>>> then H^ will be non-halting, but H is still wrong
>>>>>>>>>>>>>>>>>>>> for not answering. If H does abort, then it hasn't
>>>>>>>>>>>>>>>>>>>> proven anything, and it has been proven that it is
>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are either not bright enough to get this or
>>>>>>>>>>>>>>>>>>> dishonest.
>>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual
>>>>>>>>>>>>>>>>> capacity to understand what I am saying. This is proven
>>>>>>>>>>>>>>>>> on the basis that what I am saying can be verified as
>>>>>>>>>>>>>>>>> true entirely on the basis of the meaning of its words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that it has been shown that you keep on using the
>>>>>>>>>>>>>>>> WRONG definitions of the words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION, a
>>>>>>>>>>>>>>>> UTM EXACTLY repoduces the behavior of its input (so if
>>>>>>>>>>>>>>>> it is non-halting, so will the UTM). Also you think that
>>>>>>>>>>>>>>>> there can be a 'Correct Simulation' by something that is
>>>>>>>>>>>>>>>> NOT actully a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That just PROVES that you aren't actually working on the
>>>>>>>>>>>>>>>> Halting Problem of Computation Theory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions,
>>>>>>>>>>>>>>>>>> maybe because you just don't know the field, so don't
>>>>>>>>>>>>>>>>>> have any idea what is legal or not.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect,
>>>>>>>>>>>>>>>>>> you need to be able to explain it to someone who
>>>>>>>>>>>>>>>>>> understands Computation Theory, which is a fairly
>>>>>>>>>>>>>>>>>> specialized branch of Mathematics. Yes, it is part of
>>>>>>>>>>>>>>>>>> the foundation of Computer Science, but isn't the sort
>>>>>>>>>>>>>>>>>> of thing that a normal Computer Scientist will deal
>>>>>>>>>>>>>>>>>> with day to day.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>>>>>>> meaning of what I am saying instead of mere rote
>>>>>>>>>>>>>>>>> memorized meanings from textbooks.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, you need to learn that words have PRECISE meanings,
>>>>>>>>>>>>>>>> and you aren't allowed to change them, no mwtter how
>>>>>>>>>>>>>>>> much it 'makes sense' to do so.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The key mistake that my reviewers are making is that
>>>>>>>>>>>>>>>>> they believe that the halt decider is supposed to
>>>>>>>>>>>>>>>>> evaluate its input on the basis of some proxy for the
>>>>>>>>>>>>>>>>> actual behavior of this actual input rather than the
>>>>>>>>>>>>>>>>> actual behavior specified by this actual input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Just proves you aren't working on the Halting Problem,
>>>>>>>>>>>>>>>> as the DEFINITION of the Halting problems says that it
>>>>>>>>>>>>>>>> is, because you don't actually understand the meaning of
>>>>>>>>>>>>>>>> 'actual behavior'.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will
>>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you are supposed to report when Bill arrives at your
>>>>>>>>>>>>>>> house and Sam arrives at you house and you really really
>>>>>>>>>>>>>>> believe that Sam's arrival is a valid proxy for Bill's
>>>>>>>>>>>>>>> arrival then when I ask you did Bill arrive at your
>>>>>>>>>>>>>>> house? you say "yes" even though correct the answer is "no".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H
>>>>>>>>>>>>>> applied to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>>>>> actual behavior specified by the input to embedded_H as the
>>>>>>>>>>>>> only correct halt status criterion measure that might as
>>>>>>>>>>>>> well say that cats are not animals.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You
>>>>>>>>>>>> just refuse to accept the definition because it doesn't
>>>>>>>>>>>> match your idea of what you need.
>>>>>>>>>>>>
>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>>> specifes, The input to the decider is the description of a
>>>>>>>>>>>> computation, and the actual behavior sepecified by the input
>>>>>>>>>>>> is by defintion the behavior of that computation that the
>>>>>>>>>>>> input describes.
>>>>>>>>>>>>
>>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>>> program that is processing the input. YOUR definition of the
>>>>>>>>>>>> behavior has the problem that the behavior is no longer just
>>>>>>>>>>>> specified by 'the input' but is also a function of what
>>>>>>>>>>>> program you give that input to.
>>>>>>>>>>>>
>>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>>
>>>>>>>>>>>> This statement of your just shows how you have lost touch
>>>>>>>>>>>> with the reality of the situation. You seem to think the
>>>>>>>>>>>> Univese must be wrong because it doesn't match your
>>>>>>>>>>>> expectations. THAT is a sign of mental illness.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^>
>>>>>>>>>> Will Halt.
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^>
>>>>>>>>>> will never Halt.
>>>>>>>>>>
>>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to
>>>>>>>>> Ĥ.qn without contradiction.
>>>>>>>>
>>>>>>>> Bing a pathological liar seems to have made you lose your sense
>>>>>>>> of what is true.
>>>>>>>>
>>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>>> applied to <H^> <H^> the former uses the latter to determine its
>>>>>>>> behavior.
>>>>>>>>
>>>>>>>> The issue isn't a 'contradiction' between the behavior of the
>>>>>>>> two machines but the contradiction between the behavior of these
>>>>>>>> two machines and the concept that H is correct.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Like the guard that is only accountable for guarding the front
>>>>>>>>> door simulating halt decider embedded_H is only accountable for
>>>>>>>>> reporting whether or not its simulated input can possibly reach
>>>>>>>>> its own final state ⟨Ĥ⟩.qn.
>>>>>>>>
>>>>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>>>>
>>>>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>>>>> 'Behavior of its input', which is DEFINED as the behavior of the
>>>>>>>> ACTUAL MACHINE the input represents.
>>>>>>>
>>>>>>> You have this misconception welded into your brain.
>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>
>>>>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>>>>> represents Bill.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>>> supposed to answer on is the actual behavior of the machine that
>>>>>> the input represents.
>>>>>>
>>>>> If the court is trying to establish an alibi for Bill and you
>>>>> answer this on the basis that Bill's lawyer instead of Bill you
>>>>> would go to prison for perjury. This proves that you are not
>>>>> allowed to use the term "represents" to refer to something else
>>>>> somewhere else.
>>>>
>>>> So, do you think you should go to jail for the perjury of Ha
>>>> reporting on the behavior of Hn^ instead if Ha^?
>>>>
>>>> That is your wrong answer.
>>>>>
>>>>> When a finite string Turing machine description represents a Turing
>>>>> Machine then the UTM simulation of the finite string will always
>>>>> have computationally equivalent behavior to the direct execution of
>>>>> the Turing machine.
>>>>
>>>> Right, A REAL UTM, which never aborts its simulation, but is
>>>> non-halting if its input represents a non-halting computation, as is
>>>> part of the defintion of a UTM.
>>>
>>> When embedded_H correctly determines that the pure simulation of its
>>> input by a real UTM would never reach the final state of this input
>>> and it makes this determination in a finite number of steps, then it
>>> is necessarily correct for embedded_H  to transition to its reject
>>> state.
>>>
>>
>> Except that the 'correct determination' was based on the assumption
>> that H/embedded_H IS just a UTM,
>
> That is factually incorrect. embedded_H determines what the behavior of
> its input would be if its was simulated by UTM instead of a simulating
> halt decider.


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

<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 09 Feb 2022 15:03:04 -0600
Date: Wed, 9 Feb 2022 15:03:03 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<SvednUS4Te7mX5z_nZ2dnUU7-bHNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <OeVMJ.11688$V7da.9533@fx13.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
Lines: 488
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-c6Q1sD1u48/Cn0bNBRVQD0QYIlG8K9xbf0DHtyj5VO66loDNmiphN8f9uBxHi2zChVyjYbdE7gTUjSM!f0MbhSA87Uh/A4qQUA5pYEHZnVQ2G9M3Pi3lX8lRuOkHjPagNtdV+Y+GlvR5kB7yDiTdbz+Ywmfn
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: 28181
 by: olcott - Wed, 9 Feb 2022 21:03 UTC

On 2/9/2022 2:12 PM, Richard Damon wrote:
>
> On 2/9/22 2:37 PM, olcott wrote:
>> On 2/9/2022 1:19 PM, Richard Damon wrote:
>>> On 2/9/22 1:56 PM, olcott wrote:
>>>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/9/22 1:39 PM, olcott wrote:
>>>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of matching infinite behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had previously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been considered to be proof that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is undecidable. That
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is all that I need to refute these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program must be all knowing. To refute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the proofs I merely need to show that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their counter-example can be proved to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by construction H^ <H^> goes to H^.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and halts, and since H, to be an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accurate Halt Decider, must only go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H,Qn if the machine its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents will never halt. They you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^>. So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing you claim youhave, but only that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have amassed an amazing pile of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> yourself into thinking you have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have gaslighted yourself so you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and never will because you believe that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory, using Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders they are only accountable for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computing the mapping from their input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their correctly simulated input could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach its final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^> is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough steps for the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Linz definition of a sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps and doesn't reach a final state, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H will never reach ⟨Ĥ⟩.qn in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> any number of steps, which proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly meet the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show
>>>>>>>>>>>>>>>>>>>>>>>>>>> that does not halt is H, so H can not be a
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>> three iterations of nested simulation to match
>>>>>>>>>>>>>>>>>>>>>>>>>> the infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match
>>>>>>>>>>>>>>>>>>>>>>>>>> this pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the H^
>>>>>>>>>>>>>>>>>>>>>>>>> that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>> its inputs as if its was a guard assigned to
>>>>>>>>>>>>>>>>>>>>>>>> watch the front. If someone comes in the back
>>>>>>>>>>>>>>>>>>>>>>>> door (non-inputs) embedded_H is not even allowed
>>>>>>>>>>>>>>>>>>>>>>>> to pay attention.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>> is not the behavior of H^ applied to <H^> you are
>>>>>>>>>>>>>>>>>>>>>>> lying about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to
>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn, then nothing in the universe can
>>>>>>>>>>>>>>>>>>>>>> possibly contradict the fact that the input
>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequences of
>>>>>>>>>>>>>>>>>>>>>> configurations. If God himself said otherwise then
>>>>>>>>>>>>>>>>>>>>>> God himself would be a liar.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation
>>>>>>>>>>>>>>>>>>>>> and goes to H.Qn, then the CORRECT simulation of
>>>>>>>>>>>>>>>>>>>>> its input (that done by a REAL UTM) will show that
>>>>>>>>>>>>>>>>>>>>> it will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort, and
>>>>>>>>>>>>>>>>>>>>> thus doesn't go to H.Qn, and thus fails to be a
>>>>>>>>>>>>>>>>>>>>> correct decider, then H^ applied to <H^> is
>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts
>>>>>>>>>>>>>>>>>>>>> its simulation is a 'correct' simulation. By the
>>>>>>>>>>>>>>>>>>>>> definition in Computation Theory, this is not true.
>>>>>>>>>>>>>>>>>>>>> If you think it is, it just proves that you don't
>>>>>>>>>>>>>>>>>>>>> understand the field.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know
>>>>>>>>>>>>>>>>>>>>>> that we have a cat.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but think
>>>>>>>>>>>>>>>>>>>>> you do then you are wrong. If H aborts its
>>>>>>>>>>>>>>>>>>>>> simulation, it isn't a UTM and doesn't 'correctly'
>>>>>>>>>>>>>>>>>>>>> simulate.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of
>>>>>>>>>>>>>>>>>>>>>> configurations that cannot possibly ever reach its
>>>>>>>>>>>>>>>>>>>>>> final state then we know that we have a
>>>>>>>>>>>>>>>>>>>>>> non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>> then the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves
>>>>>>>>>>>>>>>>>>>>> just proves that if H is a UTM, which don't abort,
>>>>>>>>>>>>>>>>>>>>> then H^ will be non-halting, but H is still wrong
>>>>>>>>>>>>>>>>>>>>> for not answering. If H does abort, then it hasn't
>>>>>>>>>>>>>>>>>>>>> proven anything, and it has been proven that it is
>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are either not bright enough to get this or
>>>>>>>>>>>>>>>>>>>> dishonest.
>>>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to computer
>>>>>>>>>>>>>>>>>>>> scientists.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual
>>>>>>>>>>>>>>>>>> capacity to understand what I am saying. This is
>>>>>>>>>>>>>>>>>> proven on the basis that what I am saying can be
>>>>>>>>>>>>>>>>>> verified as true entirely on the basis of the meaning
>>>>>>>>>>>>>>>>>> of its words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that it has been shown that you keep on using
>>>>>>>>>>>>>>>>> the WRONG definitions of the words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION,
>>>>>>>>>>>>>>>>> a UTM EXACTLY repoduces the behavior of its input (so
>>>>>>>>>>>>>>>>> if it is non-halting, so will the UTM). Also you think
>>>>>>>>>>>>>>>>> that there can be a 'Correct Simulation' by something
>>>>>>>>>>>>>>>>> that is NOT actully a UTM.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That just PROVES that you aren't actually working on
>>>>>>>>>>>>>>>>> the Halting Problem of Computation Theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions,
>>>>>>>>>>>>>>>>>>> maybe because you just don't know the field, so don't
>>>>>>>>>>>>>>>>>>> have any idea what is legal or not.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect,
>>>>>>>>>>>>>>>>>>> you need to be able to explain it to someone who
>>>>>>>>>>>>>>>>>>> understands Computation Theory, which is a fairly
>>>>>>>>>>>>>>>>>>> specialized branch of Mathematics. Yes, it is part of
>>>>>>>>>>>>>>>>>>> the foundation of Computer Science, but isn't the
>>>>>>>>>>>>>>>>>>> sort of thing that a normal Computer Scientist will
>>>>>>>>>>>>>>>>>>> deal with day to day.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the deep
>>>>>>>>>>>>>>>>>> meaning of what I am saying instead of mere rote
>>>>>>>>>>>>>>>>>> memorized meanings from textbooks.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, you need to learn that words have PRECISE meanings,
>>>>>>>>>>>>>>>>> and you aren't allowed to change them, no mwtter how
>>>>>>>>>>>>>>>>> much it 'makes sense' to do so.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The key mistake that my reviewers are making is that
>>>>>>>>>>>>>>>>>> they believe that the halt decider is supposed to
>>>>>>>>>>>>>>>>>> evaluate its input on the basis of some proxy for the
>>>>>>>>>>>>>>>>>> actual behavior of this actual input rather than the
>>>>>>>>>>>>>>>>>> actual behavior specified by this actual input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Just proves you aren't working on the Halting Problem,
>>>>>>>>>>>>>>>>> as the DEFINITION of the Halting problems says that it
>>>>>>>>>>>>>>>>> is, because you don't actually understand the meaning
>>>>>>>>>>>>>>>>> of 'actual behavior'.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will
>>>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you are supposed to report when Bill arrives at your
>>>>>>>>>>>>>>>> house and Sam arrives at you house and you really really
>>>>>>>>>>>>>>>> believe that Sam's arrival is a valid proxy for Bill's
>>>>>>>>>>>>>>>> arrival then when I ask you did Bill arrive at your
>>>>>>>>>>>>>>>> house? you say "yes" even though correct the answer is
>>>>>>>>>>>>>>>> "no".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H
>>>>>>>>>>>>>>> applied to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>>>>>> actual behavior specified by the input to embedded_H as
>>>>>>>>>>>>>> the only correct halt status criterion measure that might
>>>>>>>>>>>>>> as well say that cats are not animals.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You
>>>>>>>>>>>>> just refuse to accept the definition because it doesn't
>>>>>>>>>>>>> match your idea of what you need.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>>>> specifes, The input to the decider is the description of a
>>>>>>>>>>>>> computation, and the actual behavior sepecified by the
>>>>>>>>>>>>> input is by defintion the behavior of that computation that
>>>>>>>>>>>>> the input describes.
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>>>> program that is processing the input. YOUR definition of
>>>>>>>>>>>>> the behavior has the problem that the behavior is no longer
>>>>>>>>>>>>> just specified by 'the input' but is also a function of
>>>>>>>>>>>>> what program you give that input to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This statement of your just shows how you have lost touch
>>>>>>>>>>>>> with the reality of the situation. You seem to think the
>>>>>>>>>>>>> Univese must be wrong because it doesn't match your
>>>>>>>>>>>>> expectations. THAT is a sign of mental illness.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^>
>>>>>>>>>>> Will Halt.
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^>
>>>>>>>>>>> will never Halt.
>>>>>>>>>>>
>>>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to
>>>>>>>>>> Ĥ.qn without contradiction.
>>>>>>>>>
>>>>>>>>> Bing a pathological liar seems to have made you lose your sense
>>>>>>>>> of what is true.
>>>>>>>>>
>>>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>>>> applied to <H^> <H^> the former uses the latter to determine
>>>>>>>>> its behavior.
>>>>>>>>>
>>>>>>>>> The issue isn't a 'contradiction' between the behavior of the
>>>>>>>>> two machines but the contradiction between the behavior of
>>>>>>>>> these two machines and the concept that H is correct.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Like the guard that is only accountable for guarding the front
>>>>>>>>>> door simulating halt decider embedded_H is only accountable
>>>>>>>>>> for reporting whether or not its simulated input can possibly
>>>>>>>>>> reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>
>>>>>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>>>>>
>>>>>>>>> H/embedded_H IS responsible for its answer match the the ACTUAL
>>>>>>>>> 'Behavior of its input', which is DEFINED as the behavior of
>>>>>>>>> the ACTUAL MACHINE the input represents.
>>>>>>>>
>>>>>>>> You have this misconception welded into your brain.
>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>
>>>>>>>> You answer yes because Bill's lawyer came over and Bill's lawyer
>>>>>>>> represents Bill.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>>>> supposed to answer on is the actual behavior of the machine that
>>>>>>> the input represents.
>>>>>>>
>>>>>> If the court is trying to establish an alibi for Bill and you
>>>>>> answer this on the basis that Bill's lawyer instead of Bill you
>>>>>> would go to prison for perjury. This proves that you are not
>>>>>> allowed to use the term "represents" to refer to something else
>>>>>> somewhere else.
>>>>>
>>>>> So, do you think you should go to jail for the perjury of Ha
>>>>> reporting on the behavior of Hn^ instead if Ha^?
>>>>>
>>>>> That is your wrong answer.
>>>>>>
>>>>>> When a finite string Turing machine description represents a
>>>>>> Turing Machine then the UTM simulation of the finite string will
>>>>>> always have computationally equivalent behavior to the direct
>>>>>> execution of the Turing machine.
>>>>>
>>>>> Right, A REAL UTM, which never aborts its simulation, but is
>>>>> non-halting if its input represents a non-halting computation, as
>>>>> is part of the defintion of a UTM.
>>>>
>>>> When embedded_H correctly determines that the pure simulation of its
>>>> input by a real UTM would never reach the final state of this input
>>>> and it makes this determination in a finite number of steps, then it
>>>> is necessarily correct for embedded_H  to transition to its reject
>>>> state.
>>>>
>>>
>>> Except that the 'correct determination' was based on the assumption
>>> that H/embedded_H IS just a UTM,
>>
>> That is factually incorrect. embedded_H determines what the behavior
>> of its input would be if its was simulated by UTM instead of a
>> simulating halt decider.
>
> Right, but in doing so it does NOT change the copy of H inside of H^
> into a UTM. The copy of H (you call it embedded_H) must behave exactly
> like H does. H needs to decide on what a UTM would do with its same
> input where the copy of H in that input does the same thing as H does.
>
> Unless you can show a Turing Machine diferent copies of which behave
> differently when given the same input, you haven't shown what you need
> to. (And if you could show that, that by itself would make you famous).
>


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

<J8WMJ.29109$Tr18.2452@fx42.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<HEjMJ.6348$979a.2933@fx14.iad>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 511
Message-ID: <J8WMJ.29109$Tr18.2452@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 9 Feb 2022 16:14:16 -0500
X-Received-Bytes: 29399
 by: Richard Damon - Wed, 9 Feb 2022 21:14 UTC

On 2/9/22 4:03 PM, olcott wrote:
> On 2/9/2022 2:12 PM, Richard Damon wrote:
>>
>> On 2/9/22 2:37 PM, olcott wrote:
>>> On 2/9/2022 1:19 PM, Richard Damon wrote:
>>>> On 2/9/22 1:56 PM, olcott wrote:
>>>>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/9/22 1:39 PM, olcott wrote:
>>>>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of matching infinite behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is matched H aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> previously been considered to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> undecidable. That is all that I need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program must be all knowing. To
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refute the proofs I merely need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that their counter-example can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> applied to <H^> <H^> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then by construction H^ <H^> goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, and halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider, must only go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H,Qn if the machine its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents will never halt. They you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also don't seem to understand that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computaton that <H^> <H^> represents
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS H^ applied to <H^>. So, H was just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing you claim youhave, but only that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have amassed an amazing pile of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> yourself into thinking you have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have gaslighted yourself so you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually understand what actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science to understand that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong and never will because you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory, using Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are deciders they are only accountable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for computing the mapping from their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input finite strings to an accept or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state on the basis of whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not their correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could ever reach its final state: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough steps for the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn then the input to embedded_H meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Linz definition of a sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps and doesn't reach a final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H will never reach ⟨Ĥ⟩.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in any number of steps, which proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input cannot possibly meet the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does not halt is H, so H can not be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>> three iterations of nested simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>> match the infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match
>>>>>>>>>>>>>>>>>>>>>>>>>>> this pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the
>>>>>>>>>>>>>>>>>>>>>>>>>> H^ that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>>> its inputs as if its was a guard assigned to
>>>>>>>>>>>>>>>>>>>>>>>>> watch the front. If someone comes in the back
>>>>>>>>>>>>>>>>>>>>>>>>> door (non-inputs) embedded_H is not even
>>>>>>>>>>>>>>>>>>>>>>>>> allowed to pay attention.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>> is not the behavior of H^ applied to <H^> you
>>>>>>>>>>>>>>>>>>>>>>>> are lying about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn, then nothing in the universe can
>>>>>>>>>>>>>>>>>>>>>>> possibly contradict the fact that the input
>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequences of
>>>>>>>>>>>>>>>>>>>>>>> configurations. If God himself said otherwise
>>>>>>>>>>>>>>>>>>>>>>> then God himself would be a liar.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>> and goes to H.Qn, then the CORRECT simulation of
>>>>>>>>>>>>>>>>>>>>>> its input (that done by a REAL UTM) will show that
>>>>>>>>>>>>>>>>>>>>>> it will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort,
>>>>>>>>>>>>>>>>>>>>>> and thus doesn't go to H.Qn, and thus fails to be
>>>>>>>>>>>>>>>>>>>>>> a correct decider, then H^ applied to <H^> is
>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that aborts
>>>>>>>>>>>>>>>>>>>>>> its simulation is a 'correct' simulation. By the
>>>>>>>>>>>>>>>>>>>>>> definition in Computation Theory, this is not
>>>>>>>>>>>>>>>>>>>>>> true. If you think it is, it just proves that you
>>>>>>>>>>>>>>>>>>>>>> don't understand the field.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know
>>>>>>>>>>>>>>>>>>>>>>> that we have a cat.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but
>>>>>>>>>>>>>>>>>>>>>> think you do then you are wrong. If H aborts its
>>>>>>>>>>>>>>>>>>>>>> simulation, it isn't a UTM and doesn't 'correctly'
>>>>>>>>>>>>>>>>>>>>>> simulate.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of
>>>>>>>>>>>>>>>>>>>>>>> configurations that cannot possibly ever reach
>>>>>>>>>>>>>>>>>>>>>>> its final state then we know that we have a
>>>>>>>>>>>>>>>>>>>>>>> non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>> then the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state proves
>>>>>>>>>>>>>>>>>>>>>> just proves that if H is a UTM, which don't abort,
>>>>>>>>>>>>>>>>>>>>>> then H^ will be non-halting, but H is still wrong
>>>>>>>>>>>>>>>>>>>>>> for not answering. If H does abort, then it hasn't
>>>>>>>>>>>>>>>>>>>>>> proven anything, and it has been proven that it is
>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are either not bright enough to get this or
>>>>>>>>>>>>>>>>>>>>> dishonest.
>>>>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to
>>>>>>>>>>>>>>>>>>>>> computer scientists.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual
>>>>>>>>>>>>>>>>>>> capacity to understand what I am saying. This is
>>>>>>>>>>>>>>>>>>> proven on the basis that what I am saying can be
>>>>>>>>>>>>>>>>>>> verified as true entirely on the basis of the meaning
>>>>>>>>>>>>>>>>>>> of its words.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that it has been shown that you keep on using
>>>>>>>>>>>>>>>>>> the WRONG definitions of the words.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY DEFINITION,
>>>>>>>>>>>>>>>>>> a UTM EXACTLY repoduces the behavior of its input (so
>>>>>>>>>>>>>>>>>> if it is non-halting, so will the UTM). Also you think
>>>>>>>>>>>>>>>>>> that there can be a 'Correct Simulation' by something
>>>>>>>>>>>>>>>>>> that is NOT actully a UTM.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That just PROVES that you aren't actually working on
>>>>>>>>>>>>>>>>>> the Halting Problem of Computation Theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions,
>>>>>>>>>>>>>>>>>>>> maybe because you just don't know the field, so
>>>>>>>>>>>>>>>>>>>> don't have any idea what is legal or not.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>>>>>>> Scientists' to understand, that is really incorrect,
>>>>>>>>>>>>>>>>>>>> you need to be able to explain it to someone who
>>>>>>>>>>>>>>>>>>>> understands Computation Theory, which is a fairly
>>>>>>>>>>>>>>>>>>>> specialized branch of Mathematics. Yes, it is part
>>>>>>>>>>>>>>>>>>>> of the foundation of Computer Science, but isn't the
>>>>>>>>>>>>>>>>>>>> sort of thing that a normal Computer Scientist will
>>>>>>>>>>>>>>>>>>>> deal with day to day.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the
>>>>>>>>>>>>>>>>>>> deep meaning of what I am saying instead of mere rote
>>>>>>>>>>>>>>>>>>> memorized meanings from textbooks.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, you need to learn that words have PRECISE
>>>>>>>>>>>>>>>>>> meanings, and you aren't allowed to change them, no
>>>>>>>>>>>>>>>>>> mwtter how much it 'makes sense' to do so.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The key mistake that my reviewers are making is that
>>>>>>>>>>>>>>>>>>> they believe that the halt decider is supposed to
>>>>>>>>>>>>>>>>>>> evaluate its input on the basis of some proxy for the
>>>>>>>>>>>>>>>>>>> actual behavior of this actual input rather than the
>>>>>>>>>>>>>>>>>>> actual behavior specified by this actual input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Just proves you aren't working on the Halting Problem,
>>>>>>>>>>>>>>>>>> as the DEFINITION of the Halting problems says that it
>>>>>>>>>>>>>>>>>> is, because you don't actually understand the meaning
>>>>>>>>>>>>>>>>>> of 'actual behavior'.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF M
>>>>>>>>>>>>>>>>>> applied to w halts, and to H,Qn if M applied to w will
>>>>>>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you are supposed to report when Bill arrives at your
>>>>>>>>>>>>>>>>> house and Sam arrives at you house and you really
>>>>>>>>>>>>>>>>> really believe that Sam's arrival is a valid proxy for
>>>>>>>>>>>>>>>>> Bill's arrival then when I ask you did Bill arrive at
>>>>>>>>>>>>>>>>> your house? you say "yes" even though correct the
>>>>>>>>>>>>>>>>> answer is "no".
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H
>>>>>>>>>>>>>>>> applied to wM w is based on the behavior of M applied to w.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When anyone in the universe defines something besides the
>>>>>>>>>>>>>>> actual behavior specified by the input to embedded_H as
>>>>>>>>>>>>>>> the only correct halt status criterion measure that might
>>>>>>>>>>>>>>> as well say that cats are not animals.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You
>>>>>>>>>>>>>> just refuse to accept the definition because it doesn't
>>>>>>>>>>>>>> match your idea of what you need.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>>>>> specifes, The input to the decider is the description of a
>>>>>>>>>>>>>> computation, and the actual behavior sepecified by the
>>>>>>>>>>>>>> input is by defintion the behavior of that computation
>>>>>>>>>>>>>> that the input describes.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>>>>> program that is processing the input. YOUR definition of
>>>>>>>>>>>>>> the behavior has the problem that the behavior is no
>>>>>>>>>>>>>> longer just specified by 'the input' but is also a
>>>>>>>>>>>>>> function of what program you give that input to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This statement of your just shows how you have lost touch
>>>>>>>>>>>>>> with the reality of the situation. You seem to think the
>>>>>>>>>>>>>> Univese must be wrong because it doesn't match your
>>>>>>>>>>>>>> expectations. THAT is a sign of mental illness.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^ <H^>
>>>>>>>>>>>> Will Halt.
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^ <H^>
>>>>>>>>>>>> will never Halt.
>>>>>>>>>>>>
>>>>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to
>>>>>>>>>>> Ĥ.qn without contradiction.
>>>>>>>>>>
>>>>>>>>>> Bing a pathological liar seems to have made you lose your
>>>>>>>>>> sense of what is true.
>>>>>>>>>>
>>>>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>>>>> applied to <H^> <H^> the former uses the latter to determine
>>>>>>>>>> its behavior.
>>>>>>>>>>
>>>>>>>>>> The issue isn't a 'contradiction' between the behavior of the
>>>>>>>>>> two machines but the contradiction between the behavior of
>>>>>>>>>> these two machines and the concept that H is correct.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Like the guard that is only accountable for guarding the
>>>>>>>>>>> front door simulating halt decider embedded_H is only
>>>>>>>>>>> accountable for reporting whether or not its simulated input
>>>>>>>>>>> can possibly reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>>
>>>>>>>>>> Again, you pathological lying has blinded you to the actual fact.
>>>>>>>>>>
>>>>>>>>>> H/embedded_H IS responsible for its answer match the the
>>>>>>>>>> ACTUAL 'Behavior of its input', which is DEFINED as the
>>>>>>>>>> behavior of the ACTUAL MACHINE the input represents.
>>>>>>>>>
>>>>>>>>> You have this misconception welded into your brain.
>>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>>
>>>>>>>>> You answer yes because Bill's lawyer came over and Bill's
>>>>>>>>> lawyer represents Bill.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>>>>> supposed to answer on is the actual behavior of the machine that
>>>>>>>> the input represents.
>>>>>>>>
>>>>>>> If the court is trying to establish an alibi for Bill and you
>>>>>>> answer this on the basis that Bill's lawyer instead of Bill you
>>>>>>> would go to prison for perjury. This proves that you are not
>>>>>>> allowed to use the term "represents" to refer to something else
>>>>>>> somewhere else.
>>>>>>
>>>>>> So, do you think you should go to jail for the perjury of Ha
>>>>>> reporting on the behavior of Hn^ instead if Ha^?
>>>>>>
>>>>>> That is your wrong answer.
>>>>>>>
>>>>>>> When a finite string Turing machine description represents a
>>>>>>> Turing Machine then the UTM simulation of the finite string will
>>>>>>> always have computationally equivalent behavior to the direct
>>>>>>> execution of the Turing machine.
>>>>>>
>>>>>> Right, A REAL UTM, which never aborts its simulation, but is
>>>>>> non-halting if its input represents a non-halting computation, as
>>>>>> is part of the defintion of a UTM.
>>>>>
>>>>> When embedded_H correctly determines that the pure simulation of
>>>>> its input by a real UTM would never reach the final state of this
>>>>> input and it makes this determination in a finite number of steps,
>>>>> then it is necessarily correct for embedded_H  to transition to its
>>>>> reject state.
>>>>>
>>>>
>>>> Except that the 'correct determination' was based on the assumption
>>>> that H/embedded_H IS just a UTM,
>>>
>>> That is factually incorrect. embedded_H determines what the behavior
>>> of its input would be if its was simulated by UTM instead of a
>>> simulating halt decider.
>>
>> Right, but in doing so it does NOT change the copy of H inside of H^
>> into a UTM. The copy of H (you call it embedded_H) must behave exactly
>> like H does. H needs to decide on what a UTM would do with its same
>> input where the copy of H in that input does the same thing as H does.
>>
>> Unless you can show a Turing Machine diferent copies of which behave
>> differently when given the same input, you haven't shown what you need
>> to. (And if you could show that, that by itself would make you famous).
>>
>
> I have a really great answer for this yet deleted it because of your
> subterfuge on the next line.


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

<su1bj6$qko$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Date: Wed, 9 Feb 2022 15:27:02 -0600
Organization: A noiseless patient Spider
Lines: 490
Message-ID: <su1bj6$qko$1@dont-email.me>
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<EPSdnZqQs6B9UZz_nZ2dnUU7-QXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 9 Feb 2022 21:27:02 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="52880b110edbd35d3ee01e686669fd61";
logging-data="27288"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/UDzihq0xAa2301KtGpjxf"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.6.0
Cancel-Lock: sha1:TLzrB5WcGN6vIT0IM/nh1y6cvQA=
In-Reply-To: <J8WMJ.29109$Tr18.2452@fx42.iad>
Content-Language: en-US
 by: olcott - Wed, 9 Feb 2022 21:27 UTC

On 2/9/2022 3:14 PM, Richard Damon wrote:
> On 2/9/22 4:03 PM, olcott wrote:
>> On 2/9/2022 2:12 PM, Richard Damon wrote:
>>>
>>> On 2/9/22 2:37 PM, olcott wrote:
>>>> On 2/9/2022 1:19 PM, Richard Damon wrote:
>>>>> On 2/9/22 1:56 PM, olcott wrote:
>>>>>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/9/22 1:39 PM, olcott wrote:
>>>>>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of matching infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is matched H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. Otherwise H transitions to its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> previously been considered to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> undecidable. That is all that I need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program must be all knowing. To
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refute the proofs I merely need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that their counter-example can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H applied to <H^> <H^> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then by construction H^ <H^> goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, and halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider, must only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H,Qn if the machine its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents will never halt. They you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also don't seem to understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the computaton that <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents IS H^ applied to <H^>. So,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing you claim youhave, but only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you have amassed an amazing pile
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> yourself into thinking you have shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have gaslighted yourself so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't actually understand what actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computer science to understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are wrong and never will because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory, using Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are deciders they are only accountable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for computing the mapping from their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input finite strings to an accept or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject state on the basis of whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not their correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could ever reach its final state: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough steps for the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩.qn then the input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meets the Linz definition of a sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps and doesn't reach a final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H will never reach ⟨Ĥ⟩.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in any number of steps, which proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input cannot possibly meet the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does not halt is H, so H can not be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>> three iterations of nested simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the infinitely nested simulation pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the
>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> of its inputs as if its was a guard assigned
>>>>>>>>>>>>>>>>>>>>>>>>>> to watch the front. If someone comes in the
>>>>>>>>>>>>>>>>>>>>>>>>>> back door (non-inputs) embedded_H is not even
>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to pay attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>> is not the behavior of H^ applied to <H^> you
>>>>>>>>>>>>>>>>>>>>>>>>> are lying about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn, then nothing in the universe
>>>>>>>>>>>>>>>>>>>>>>>> can possibly contradict the fact that the input
>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequences of
>>>>>>>>>>>>>>>>>>>>>>>> configurations. If God himself said otherwise
>>>>>>>>>>>>>>>>>>>>>>>> then God himself would be a liar.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>> and goes to H.Qn, then the CORRECT simulation of
>>>>>>>>>>>>>>>>>>>>>>> its input (that done by a REAL UTM) will show
>>>>>>>>>>>>>>>>>>>>>>> that it will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort,
>>>>>>>>>>>>>>>>>>>>>>> and thus doesn't go to H.Qn, and thus fails to be
>>>>>>>>>>>>>>>>>>>>>>> a correct decider, then H^ applied to <H^> is
>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that
>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation is a 'correct' simulation.
>>>>>>>>>>>>>>>>>>>>>>> By the definition in Computation Theory, this is
>>>>>>>>>>>>>>>>>>>>>>> not true. If you think it is, it just proves that
>>>>>>>>>>>>>>>>>>>>>>> you don't understand the field.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we know
>>>>>>>>>>>>>>>>>>>>>>>> that we have a cat.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but
>>>>>>>>>>>>>>>>>>>>>>> think you do then you are wrong. If H aborts its
>>>>>>>>>>>>>>>>>>>>>>> simulation, it isn't a UTM and doesn't
>>>>>>>>>>>>>>>>>>>>>>> 'correctly' simulate.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of
>>>>>>>>>>>>>>>>>>>>>>>> configurations that cannot possibly ever reach
>>>>>>>>>>>>>>>>>>>>>>>> its final state then we know that we have a
>>>>>>>>>>>>>>>>>>>>>>>> non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>> then the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state
>>>>>>>>>>>>>>>>>>>>>>> proves just proves that if H is a UTM, which
>>>>>>>>>>>>>>>>>>>>>>> don't abort, then H^ will be non-halting, but H
>>>>>>>>>>>>>>>>>>>>>>> is still wrong for not answering. If H does
>>>>>>>>>>>>>>>>>>>>>>> abort, then it hasn't proven anything, and it has
>>>>>>>>>>>>>>>>>>>>>>> been proven that it is wrong.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are either not bright enough to get this or
>>>>>>>>>>>>>>>>>>>>>> dishonest.
>>>>>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to
>>>>>>>>>>>>>>>>>>>>>> computer scientists.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing by
>>>>>>>>>>>>>>>>>>>>> insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual
>>>>>>>>>>>>>>>>>>>> capacity to understand what I am saying. This is
>>>>>>>>>>>>>>>>>>>> proven on the basis that what I am saying can be
>>>>>>>>>>>>>>>>>>>> verified as true entirely on the basis of the
>>>>>>>>>>>>>>>>>>>> meaning of its words.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that it has been shown that you keep on using
>>>>>>>>>>>>>>>>>>> the WRONG definitions of the words.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY
>>>>>>>>>>>>>>>>>>> DEFINITION, a UTM EXACTLY repoduces the behavior of
>>>>>>>>>>>>>>>>>>> its input (so if it is non-halting, so will the UTM).
>>>>>>>>>>>>>>>>>>> Also you think that there can be a 'Correct
>>>>>>>>>>>>>>>>>>> Simulation' by something that is NOT actully a UTM.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That just PROVES that you aren't actually working on
>>>>>>>>>>>>>>>>>>> the Halting Problem of Computation Theory.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions,
>>>>>>>>>>>>>>>>>>>>> maybe because you just don't know the field, so
>>>>>>>>>>>>>>>>>>>>> don't have any idea what is legal or not.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Also note, you keep talking about needing 'Computer
>>>>>>>>>>>>>>>>>>>>> Scientists' to understand, that is really
>>>>>>>>>>>>>>>>>>>>> incorrect, you need to be able to explain it to
>>>>>>>>>>>>>>>>>>>>> someone who understands Computation Theory, which
>>>>>>>>>>>>>>>>>>>>> is a fairly specialized branch of Mathematics. Yes,
>>>>>>>>>>>>>>>>>>>>> it is part of the foundation of Computer Science,
>>>>>>>>>>>>>>>>>>>>> but isn't the sort of thing that a normal Computer
>>>>>>>>>>>>>>>>>>>>> Scientist will deal with day to day.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the
>>>>>>>>>>>>>>>>>>>> deep meaning of what I am saying instead of mere
>>>>>>>>>>>>>>>>>>>> rote memorized meanings from textbooks.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, you need to learn that words have PRECISE
>>>>>>>>>>>>>>>>>>> meanings, and you aren't allowed to change them, no
>>>>>>>>>>>>>>>>>>> mwtter how much it 'makes sense' to do so.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The key mistake that my reviewers are making is that
>>>>>>>>>>>>>>>>>>>> they believe that the halt decider is supposed to
>>>>>>>>>>>>>>>>>>>> evaluate its input on the basis of some proxy for
>>>>>>>>>>>>>>>>>>>> the actual behavior of this actual input rather than
>>>>>>>>>>>>>>>>>>>> the actual behavior specified by this actual input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Just proves you aren't working on the Halting
>>>>>>>>>>>>>>>>>>> Problem, as the DEFINITION of the Halting problems
>>>>>>>>>>>>>>>>>>> says that it is, because you don't actually
>>>>>>>>>>>>>>>>>>> understand the meaning of 'actual behavior'.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF
>>>>>>>>>>>>>>>>>>> M applied to w halts, and to H,Qn if M applied to w
>>>>>>>>>>>>>>>>>>> will never halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If you are supposed to report when Bill arrives at
>>>>>>>>>>>>>>>>>> your house and Sam arrives at you house and you really
>>>>>>>>>>>>>>>>>> really believe that Sam's arrival is a valid proxy for
>>>>>>>>>>>>>>>>>> Bill's arrival then when I ask you did Bill arrive at
>>>>>>>>>>>>>>>>>> your house? you say "yes" even though correct the
>>>>>>>>>>>>>>>>>> answer is "no".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H
>>>>>>>>>>>>>>>>> applied to wM w is based on the behavior of M applied
>>>>>>>>>>>>>>>>> to w.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When anyone in the universe defines something besides
>>>>>>>>>>>>>>>> the actual behavior specified by the input to embedded_H
>>>>>>>>>>>>>>>> as the only correct halt status criterion measure that
>>>>>>>>>>>>>>>> might as well say that cats are not animals.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just shows your problem in comprehension, doesn't it. You
>>>>>>>>>>>>>>> just refuse to accept the definition because it doesn't
>>>>>>>>>>>>>>> match your idea of what you need.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>>>>>> specifes, The input to the decider is the description of
>>>>>>>>>>>>>>> a computation, and the actual behavior sepecified by the
>>>>>>>>>>>>>>> input is by defintion the behavior of that computation
>>>>>>>>>>>>>>> that the input describes.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>>>>>> program that is processing the input. YOUR definition of
>>>>>>>>>>>>>>> the behavior has the problem that the behavior is no
>>>>>>>>>>>>>>> longer just specified by 'the input' but is also a
>>>>>>>>>>>>>>> function of what program you give that input to.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This statement of your just shows how you have lost touch
>>>>>>>>>>>>>>> with the reality of the situation. You seem to think the
>>>>>>>>>>>>>>> Univese must be wrong because it doesn't match your
>>>>>>>>>>>>>>> expectations. THAT is a sign of mental illness.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^
>>>>>>>>>>>>> <H^> Will Halt.
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^
>>>>>>>>>>>>> <H^> will never Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition to
>>>>>>>>>>>> Ĥ.qn without contradiction.
>>>>>>>>>>>
>>>>>>>>>>> Bing a pathological liar seems to have made you lose your
>>>>>>>>>>> sense of what is true.
>>>>>>>>>>>
>>>>>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>>>>>> applied to <H^> <H^> the former uses the latter to determine
>>>>>>>>>>> its behavior.
>>>>>>>>>>>
>>>>>>>>>>> The issue isn't a 'contradiction' between the behavior of the
>>>>>>>>>>> two machines but the contradiction between the behavior of
>>>>>>>>>>> these two machines and the concept that H is correct.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Like the guard that is only accountable for guarding the
>>>>>>>>>>>> front door simulating halt decider embedded_H is only
>>>>>>>>>>>> accountable for reporting whether or not its simulated input
>>>>>>>>>>>> can possibly reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>>>
>>>>>>>>>>> Again, you pathological lying has blinded you to the actual
>>>>>>>>>>> fact.
>>>>>>>>>>>
>>>>>>>>>>> H/embedded_H IS responsible for its answer match the the
>>>>>>>>>>> ACTUAL 'Behavior of its input', which is DEFINED as the
>>>>>>>>>>> behavior of the ACTUAL MACHINE the input represents.
>>>>>>>>>>
>>>>>>>>>> You have this misconception welded into your brain.
>>>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>>>
>>>>>>>>>> You answer yes because Bill's lawyer came over and Bill's
>>>>>>>>>> lawyer represents Bill.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>>>>>> supposed to answer on is the actual behavior of the machine
>>>>>>>>> that the input represents.
>>>>>>>>>
>>>>>>>> If the court is trying to establish an alibi for Bill and you
>>>>>>>> answer this on the basis that Bill's lawyer instead of Bill you
>>>>>>>> would go to prison for perjury. This proves that you are not
>>>>>>>> allowed to use the term "represents" to refer to something else
>>>>>>>> somewhere else.
>>>>>>>
>>>>>>> So, do you think you should go to jail for the perjury of Ha
>>>>>>> reporting on the behavior of Hn^ instead if Ha^?
>>>>>>>
>>>>>>> That is your wrong answer.
>>>>>>>>
>>>>>>>> When a finite string Turing machine description represents a
>>>>>>>> Turing Machine then the UTM simulation of the finite string will
>>>>>>>> always have computationally equivalent behavior to the direct
>>>>>>>> execution of the Turing machine.
>>>>>>>
>>>>>>> Right, A REAL UTM, which never aborts its simulation, but is
>>>>>>> non-halting if its input represents a non-halting computation, as
>>>>>>> is part of the defintion of a UTM.
>>>>>>
>>>>>> When embedded_H correctly determines that the pure simulation of
>>>>>> its input by a real UTM would never reach the final state of this
>>>>>> input and it makes this determination in a finite number of steps,
>>>>>> then it is necessarily correct for embedded_H  to transition to
>>>>>> its reject state.
>>>>>>
>>>>>
>>>>> Except that the 'correct determination' was based on the assumption
>>>>> that H/embedded_H IS just a UTM,
>>>>
>>>> That is factually incorrect. embedded_H determines what the behavior
>>>> of its input would be if its was simulated by UTM instead of a
>>>> simulating halt decider.
>>>
>>> Right, but in doing so it does NOT change the copy of H inside of H^
>>> into a UTM. The copy of H (you call it embedded_H) must behave
>>> exactly like H does. H needs to decide on what a UTM would do with
>>> its same input where the copy of H in that input does the same thing
>>> as H does.
>>>
>>> Unless you can show a Turing Machine diferent copies of which behave
>>> differently when given the same input, you haven't shown what you
>>> need to. (And if you could show that, that by itself would make you
>>> famous).
>>>
>>
>> I have a really great answer for this yet deleted it because of your
>> subterfuge on the next line.
>
> What 'subterfuge', that was just a simple statement of facts based on
> definitons.
>


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

<J_WMJ.41239$%uX7.34935@fx38.iad>

 copy mid

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

 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!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.6.0
Subject: Re: Concise refutation of halting problem proofs V62 [ misconceptions
]
Content-Language: en-US
Newsgroups: comp.theory
References: <vc-dndgn0rt7amL8nZ2dnUU7-LXNnZ2d@giganews.com>
<7ckMJ.40194$%uX7.13960@fx38.iad> <stsv18$6e3$1@dont-email.me>
<2UsMJ.18969$3jp8.698@fx33.iad> <stu2kf$4hg$1@dont-email.me>
<lyDMJ.18606$z688.8500@fx35.iad>
<NeednRc4XuPYlp7_nZ2dnUU7-VXNnZ2d@giganews.com>
<AXEMJ.6305$4vG9.2509@fx19.iad>
<OFydnQVyE80muZ7_nZ2dnZeNn_XNnZ2d@giganews.com>
<udOMJ.5581$0vE9.5549@fx17.iad>
<A4SdnauKG-d0IJ7_nZ2dnUU7-RHNnZ2d@giganews.com>
<4mPMJ.19776$iK66.4863@fx46.iad>
<k5OdnYQlAcHXcZ7_nZ2dnUU7-YfNnZ2d@giganews.com>
<KgSMJ.47860$t2Bb.36697@fx98.iad>
<BYadnf5XWaGHaJ7_nZ2dnUU7-VHNnZ2d@giganews.com>
<zXSMJ.7936$979a.7156@fx14.iad>
<t8mdnWUaS5_sl5n_nZ2dnUU7-QXNnZ2d@giganews.com>
<i0UMJ.29891$Lbb6.12914@fx45.iad>
<HVudnXKnrdOxk5n_nZ2dnZeNn_fNnZ2d@giganews.com>
<stUMJ.47863$t2Bb.14394@fx98.iad> <su156n$292$1@dont-email.me>
<OeVMJ.11688$V7da.9533@fx13.iad>
<JsednR7NVO2VsZn_nZ2dnUU7-T_NnZ2d@giganews.com>
<J8WMJ.29109$Tr18.2452@fx42.iad> <su1bj6$qko$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <su1bj6$qko$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 506
Message-ID: <J_WMJ.41239$%uX7.34935@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: Wed, 9 Feb 2022 17:11:52 -0500
X-Received-Bytes: 30224
 by: Richard Damon - Wed, 9 Feb 2022 22:11 UTC

On 2/9/22 4:27 PM, olcott wrote:
> On 2/9/2022 3:14 PM, Richard Damon wrote:
>> On 2/9/22 4:03 PM, olcott wrote:
>>> On 2/9/2022 2:12 PM, Richard Damon wrote:
>>>>
>>>> On 2/9/22 2:37 PM, olcott wrote:
>>>>> On 2/9/2022 1:19 PM, Richard Damon wrote:
>>>>>> On 2/9/22 1:56 PM, olcott wrote:
>>>>>>> On 2/9/2022 12:48 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/9/22 1:39 PM, olcott wrote:
>>>>>>>>> On 2/9/2022 11:35 AM, Richard Damon wrote:
>>>>>>>>>> On 2/9/22 12:08 PM, olcott wrote:
>>>>>>>>>>> On 2/9/2022 10:49 AM, Richard Damon wrote:
>>>>>>>>>>>> On 2/9/22 11:31 AM, olcott wrote:
>>>>>>>>>>>>> On 2/9/2022 7:30 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 2/9/22 8:13 AM, olcott wrote:
>>>>>>>>>>>>>>> On 2/9/2022 6:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/8/22 9:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/8/2022 7:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/8/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/8/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/8/22 10:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/8/2022 5:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/8/22 12:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 7:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 8:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/22 9:59 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2022 5:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 10:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 3:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 2:33 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/22 3:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2022 1:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, February 6, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8:31:41 AM UTC-8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H determines [halting] on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of matching infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When an infinite behavior pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is matched H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to its final reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. Otherwise H transitions to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept state when its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ends.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is incomplete because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not cover the case where the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine neither halts nor matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an "infinite behavior pattern".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It covers the case that had
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> previously been considered to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof that the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> undecidable. That is all that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need to refute these proofs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You need to prove a theorem: There
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a finite set of patterns such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that every Turing machine either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts or matches one of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But I feel sure that theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To solve the halting problem my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> program must be all knowing. To
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refute the proofs I merely need to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that their counter-example can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be proved to never halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you just ignore the fact that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H applied to <H^> <H^> goes to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then by construction H^ <H^> goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn, and halts, and since H, to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accurate Halt Decider, must only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H,Qn if the machine its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents will never halt. They you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also don't seem to understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the computaton that <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents IS H^ applied to <H^>.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, H was just wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you haven't actually proved the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing you claim youhave, but only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you have amassed an amazing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pile of unsound logic based on wrong
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions that have hoodwinked
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> yourself into thinking you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown something useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are so good at doing this that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have gaslighted yourself so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't actually understand what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual Truth is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You simply do know know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computer science to understand that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are wrong and never will because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you believe that you are right.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you clearly don't know enough
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation Theory to talk about it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since the is a Theorm in Computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Theory, using Computation Theory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Deffinitions, that is your problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because all simulating halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are deciders they are only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accountable for computing the mapping
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from their input finite strings to an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state on the basis
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of whether or not their correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input could ever reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state: ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if you are working on the Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computation Theory, BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, the meaning of 'correcty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulted' is simulation by a REAL UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which BY DEFINITION exactly matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of Computation that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of, which for <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If an infinite number is steps is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough steps for the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H to transition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩.qn then the input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meets the Linz definition of a sequence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of configurations that never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If embedded_H DOES an infinite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps and doesn't reach a final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it shows its input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H matches this infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the same three iterations:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you agreed show the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H will never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.qn in any number of steps, which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that this input cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meet the Linz definition of halting:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OK, so the only computatiopn that you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does not halt is H, so H can not be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In the above example embedded_H simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> three iterations of nested simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match the infinitely nested simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In reality it needs less than this to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And if it doesn't do an infinite number, the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ that is using it will Halt,
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H only examines the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> of its inputs as if its was a guard assigned
>>>>>>>>>>>>>>>>>>>>>>>>>>> to watch the front. If someone comes in the
>>>>>>>>>>>>>>>>>>>>>>>>>>> back door (non-inputs) embedded_H is not even
>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to pay attention.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If the 'actual behavior' of the input <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> is not the behavior of H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>> you are lying about doing the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If it is true that the simulated input to
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final
>>>>>>>>>>>>>>>>>>>>>>>>> state of ⟨Ĥ⟩.qn, then nothing in the universe
>>>>>>>>>>>>>>>>>>>>>>>>> can possibly contradict the fact that the input
>>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequences of
>>>>>>>>>>>>>>>>>>>>>>>>> configurations. If God himself said otherwise
>>>>>>>>>>>>>>>>>>>>>>>>> then God himself would be a liar.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Except that if H/embedded_H aborts its
>>>>>>>>>>>>>>>>>>>>>>>> simulation and goes to H.Qn, then the CORRECT
>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input (that done by a REAL
>>>>>>>>>>>>>>>>>>>>>>>> UTM) will show that it will go to H^.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> All you have proven is that if H doesn't abort,
>>>>>>>>>>>>>>>>>>>>>>>> and thus doesn't go to H.Qn, and thus fails to
>>>>>>>>>>>>>>>>>>>>>>>> be a correct decider, then H^ applied to <H^> is
>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You keep on thinking that a simulation that
>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation is a 'correct' simulation.
>>>>>>>>>>>>>>>>>>>>>>>> By the definition in Computation Theory, this is
>>>>>>>>>>>>>>>>>>>>>>>> not true. If you think it is, it just proves
>>>>>>>>>>>>>>>>>>>>>>>> that you don't understand the field.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a black cat then we
>>>>>>>>>>>>>>>>>>>>>>>>> know that we have a cat.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Except that if you DON'T have a black cat but
>>>>>>>>>>>>>>>>>>>>>>>> think you do then you are wrong. If H aborts its
>>>>>>>>>>>>>>>>>>>>>>>> simulation, it isn't a UTM and doesn't
>>>>>>>>>>>>>>>>>>>>>>>> 'correctly' simulate.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If we know that we have a sequence of
>>>>>>>>>>>>>>>>>>>>>>>>> configurations that cannot possibly ever reach
>>>>>>>>>>>>>>>>>>>>>>>>> its final state then we know that we have a
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Except that is has been PROVEN that if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>> then the pattern WILL reach the final state.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The fact that H can't ever reach that state
>>>>>>>>>>>>>>>>>>>>>>>> proves just proves that if H is a UTM, which
>>>>>>>>>>>>>>>>>>>>>>>> don't abort, then H^ will be non-halting, but H
>>>>>>>>>>>>>>>>>>>>>>>> is still wrong for not answering. If H does
>>>>>>>>>>>>>>>>>>>>>>>> abort, then it hasn't proven anything, and it
>>>>>>>>>>>>>>>>>>>>>>>> has been proven that it is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> FAIL
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are either not bright enough to get this or
>>>>>>>>>>>>>>>>>>>>>>> dishonest.
>>>>>>>>>>>>>>>>>>>>>>> I don't care which, I need to up my game to
>>>>>>>>>>>>>>>>>>>>>>> computer scientists.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, can't refute what I say so you go to arguing
>>>>>>>>>>>>>>>>>>>>>> by insults, classic Olcott logical fallicy.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Fundamentally you seem to lack the intellectual
>>>>>>>>>>>>>>>>>>>>> capacity to understand what I am saying. This is
>>>>>>>>>>>>>>>>>>>>> proven on the basis that what I am saying can be
>>>>>>>>>>>>>>>>>>>>> verified as true entirely on the basis of the
>>>>>>>>>>>>>>>>>>>>> meaning of its words.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that it has been shown that you keep on using
>>>>>>>>>>>>>>>>>>>> the WRONG definitions of the words.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A UTM can NEVER abort its simulation as BY
>>>>>>>>>>>>>>>>>>>> DEFINITION, a UTM EXACTLY repoduces the behavior of
>>>>>>>>>>>>>>>>>>>> its input (so if it is non-halting, so will the
>>>>>>>>>>>>>>>>>>>> UTM). Also you think that there can be a 'Correct
>>>>>>>>>>>>>>>>>>>> Simulation' by something that is NOT actully a UTM.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Care to show anywhere where your misdefinitions are
>>>>>>>>>>>>>>>>>>>> support in the field fo Computation Theory.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That just PROVES that you aren't actually working on
>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computation Theory.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Face it, you are just WRONG about your assertions,
>>>>>>>>>>>>>>>>>>>>>> maybe because you just don't know the field, so
>>>>>>>>>>>>>>>>>>>>>> don't have any idea what is legal or not.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Also note, you keep talking about needing
>>>>>>>>>>>>>>>>>>>>>> 'Computer Scientists' to understand, that is
>>>>>>>>>>>>>>>>>>>>>> really incorrect, you need to be able to explain
>>>>>>>>>>>>>>>>>>>>>> it to someone who understands Computation Theory,
>>>>>>>>>>>>>>>>>>>>>> which is a fairly specialized branch of
>>>>>>>>>>>>>>>>>>>>>> Mathematics. Yes, it is part of the foundation of
>>>>>>>>>>>>>>>>>>>>>> Computer Science, but isn't the sort of thing that
>>>>>>>>>>>>>>>>>>>>>> a normal Computer Scientist will deal with day to
>>>>>>>>>>>>>>>>>>>>>> day.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I need someone to analyze what I am saying on the
>>>>>>>>>>>>>>>>>>>>> deep meaning of what I am saying instead of mere
>>>>>>>>>>>>>>>>>>>>> rote memorized meanings from textbooks.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, you need to learn that words have PRECISE
>>>>>>>>>>>>>>>>>>>> meanings, and you aren't allowed to change them, no
>>>>>>>>>>>>>>>>>>>> mwtter how much it 'makes sense' to do so.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The key mistake that my reviewers are making is
>>>>>>>>>>>>>>>>>>>>> that they believe that the halt decider is supposed
>>>>>>>>>>>>>>>>>>>>> to evaluate its input on the basis of some proxy
>>>>>>>>>>>>>>>>>>>>> for the actual behavior of this actual input rather
>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by this actual
>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Just proves you aren't working on the Halting
>>>>>>>>>>>>>>>>>>>> Problem, as the DEFINITION of the Halting problems
>>>>>>>>>>>>>>>>>>>> says that it is, because you don't actually
>>>>>>>>>>>>>>>>>>>> understand the meaning of 'actual behavior'.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> From Linz, H applied to wM w needs to go to H.Qy IFF
>>>>>>>>>>>>>>>>>>>> M applied to w halts, and to H,Qn if M applied to w
>>>>>>>>>>>>>>>>>>>> will never halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you are supposed to report when Bill arrives at
>>>>>>>>>>>>>>>>>>> your house and Sam arrives at you house and you
>>>>>>>>>>>>>>>>>>> really really believe that Sam's arrival is a valid
>>>>>>>>>>>>>>>>>>> proxy for Bill's arrival then when I ask you did Bill
>>>>>>>>>>>>>>>>>>> arrive at your house? you say "yes" even though
>>>>>>>>>>>>>>>>>>> correct the answer is "no".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You really like to make you Herrings Red, don't you.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> REMEMBER, the DEFINTION of a Halt Decider is that H
>>>>>>>>>>>>>>>>>> applied to wM w is based on the behavior of M applied
>>>>>>>>>>>>>>>>>> to w.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> YOU are the one making the wrong report.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When anyone in the universe defines something besides
>>>>>>>>>>>>>>>>> the actual behavior specified by the input to
>>>>>>>>>>>>>>>>> embedded_H as the only correct halt status criterion
>>>>>>>>>>>>>>>>> measure that might as well say that cats are not animals.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Just shows your problem in comprehension, doesn't it.
>>>>>>>>>>>>>>>> You just refuse to accept the definition because it
>>>>>>>>>>>>>>>> doesn't match your idea of what you need.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note, 'The Actual Behavior specifeid by the input' IS
>>>>>>>>>>>>>>>> precisly defined, and it IS the behavior that the input
>>>>>>>>>>>>>>>> specifes, The input to the decider is the description of
>>>>>>>>>>>>>>>> a computation, and the actual behavior sepecified by the
>>>>>>>>>>>>>>>> input is by defintion the behavior of that computation
>>>>>>>>>>>>>>>> that the input describes.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> YOU are the one that wants to change it to not be the
>>>>>>>>>>>>>>>> behavior specified by the input, but the behavior of the
>>>>>>>>>>>>>>>> program that is processing the input. YOUR definition of
>>>>>>>>>>>>>>>> the behavior has the problem that the behavior is no
>>>>>>>>>>>>>>>> longer just specified by 'the input' but is also a
>>>>>>>>>>>>>>>> function of what program you give that input to.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Your logic is just not sound, and sometimes I wonder how
>>>>>>>>>>>>>>>> sound your mind is.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This statement of your just shows how you have lost
>>>>>>>>>>>>>>>> touch with the reality of the situation. You seem to
>>>>>>>>>>>>>>>> think the Univese must be wrong because it doesn't match
>>>>>>>>>>>>>>>> your expectations. THAT is a sign of mental illness.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qy which it is supposed to do if H^
>>>>>>>>>>>>>> <H^> Will Halt.
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> IF H <H^> <H^> -> H.Qn which it is supposed to do if H^
>>>>>>>>>>>>>> <H^> will never Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> you keep forgetting the conditions, which are important.
>>>>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ is an entirely different sequence of
>>>>>>>>>>>>> configurations than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ therefore
>>>>>>>>>>>>> embedded_H can transition to Ĥ.qn causing Ĥ to transition
>>>>>>>>>>>>> to Ĥ.qn without contradiction.
>>>>>>>>>>>>
>>>>>>>>>>>> Bing a pathological liar seems to have made you lose your
>>>>>>>>>>>> sense of what is true.
>>>>>>>>>>>>
>>>>>>>>>>>> While H^ applied to <H^> IS a different computation then H
>>>>>>>>>>>> applied to <H^> <H^> the former uses the latter to determine
>>>>>>>>>>>> its behavior.
>>>>>>>>>>>>
>>>>>>>>>>>> The issue isn't a 'contradiction' between the behavior of
>>>>>>>>>>>> the two machines but the contradiction between the behavior
>>>>>>>>>>>> of these two machines and the concept that H is correct.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Like the guard that is only accountable for guarding the
>>>>>>>>>>>>> front door simulating halt decider embedded_H is only
>>>>>>>>>>>>> accountable for reporting whether or not its simulated
>>>>>>>>>>>>> input can possibly reach its own final state ⟨Ĥ⟩.qn.
>>>>>>>>>>>>
>>>>>>>>>>>> Again, you pathological lying has blinded you to the actual
>>>>>>>>>>>> fact.
>>>>>>>>>>>>
>>>>>>>>>>>> H/embedded_H IS responsible for its answer match the the
>>>>>>>>>>>> ACTUAL 'Behavior of its input', which is DEFINED as the
>>>>>>>>>>>> behavior of the ACTUAL MACHINE the input represents.
>>>>>>>>>>>
>>>>>>>>>>> You have this misconception welded into your brain.
>>>>>>>>>>> That is just like asking did Bill come over last night?
>>>>>>>>>>>
>>>>>>>>>>> You answer yes because Bill's lawyer came over and Bill's
>>>>>>>>>>> lawyer represents Bill.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Say what you will, but the DEFINTION of what a Halt Decider is
>>>>>>>>>> supposed to answer on is the actual behavior of the machine
>>>>>>>>>> that the input represents.
>>>>>>>>>>
>>>>>>>>> If the court is trying to establish an alibi for Bill and you
>>>>>>>>> answer this on the basis that Bill's lawyer instead of Bill you
>>>>>>>>> would go to prison for perjury. This proves that you are not
>>>>>>>>> allowed to use the term "represents" to refer to something else
>>>>>>>>> somewhere else.
>>>>>>>>
>>>>>>>> So, do you think you should go to jail for the perjury of Ha
>>>>>>>> reporting on the behavior of Hn^ instead if Ha^?
>>>>>>>>
>>>>>>>> That is your wrong answer.
>>>>>>>>>
>>>>>>>>> When a finite string Turing machine description represents a
>>>>>>>>> Turing Machine then the UTM simulation of the finite string
>>>>>>>>> will always have computationally equivalent behavior to the
>>>>>>>>> direct execution of the Turing machine.
>>>>>>>>
>>>>>>>> Right, A REAL UTM, which never aborts its simulation, but is
>>>>>>>> non-halting if its input represents a non-halting computation,
>>>>>>>> as is part of the defintion of a UTM.
>>>>>>>
>>>>>>> When embedded_H correctly determines that the pure simulation of
>>>>>>> its input by a real UTM would never reach the final state of this
>>>>>>> input and it makes this determination in a finite number of
>>>>>>> steps, then it is necessarily correct for embedded_H  to
>>>>>>> transition to its reject state.
>>>>>>>
>>>>>>
>>>>>> Except that the 'correct determination' was based on the
>>>>>> assumption that H/embedded_H IS just a UTM,
>>>>>
>>>>> That is factually incorrect. embedded_H determines what the
>>>>> behavior of its input would be if its was simulated by UTM instead
>>>>> of a simulating halt decider.
>>>>
>>>> Right, but in doing so it does NOT change the copy of H inside of H^
>>>> into a UTM. The copy of H (you call it embedded_H) must behave
>>>> exactly like H does. H needs to decide on what a UTM would do with
>>>> its same input where the copy of H in that input does the same thing
>>>> as H does.
>>>>
>>>> Unless you can show a Turing Machine diferent copies of which behave
>>>> differently when given the same input, you haven't shown what you
>>>> need to. (And if you could show that, that by itself would make you
>>>> famous).
>>>>
>>>
>>> I have a really great answer for this yet deleted it because of your
>>> subterfuge on the next line.
>>
>> What 'subterfuge', that was just a simple statement of facts based on
>> definitons.
>>
>
> I repeatedly tell you that infinite behavior can be detected in finite
> steps and you reject this out-of-hand.
>


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

rocksolid light 0.9.7
clearnet tor