Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Math is like love -- a simple idea but it can get complicated. -- R. Drabek

devel / comp.theory / Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

SubjectAuthor
* representing binary number naturallyLew Pitcher
`* representing binary number naturallyKaz Kylheku
 `* representing binary number naturally [The Halting Problem proofsolcott
  +* representing binary number naturally [The Halting ProblemMr Flibble
  |`* [The Halting Problem proofs have a fatal flaw]olcott
  | `* [The Halting Problem proofs have a fatal flaw]Mr Flibble
  |  `* The Halting Problem proofs have a fatal flawolcott
  |   +* The Halting Problem proofs have a fatal flawMr Flibble
  |   |`* The Halting Problem proofs have a fatal flawolcott
  |   | `- The Halting Problem proofs have a fatal flawMr Flibble
  |   `* The Halting Problem proofs have a fatal flawRichard Damon
  |    `* The Halting Problem proofs have a fatal flawolcott
  |     `* The Halting Problem proofs have a fatal flawRichard Damon
  |      `* The Halting Problem proofs have a fatal flawolcott
  |       `* The Halting Problem proofs have a fatal flawRichard Damon
  |        `* The Halting Problem proofs have a fatal flawolcott
  |         `* The Halting Problem proofs have a fatal flawRichard Damon
  |          `* The Halting Problem proofs have a fatal flawolcott
  |           `* The Halting Problem proofs have a fatal flawRichard Damon
  |            +* The Halting Problem proofs have a fatal flawolcott
  |            |`* The Halting Problem proofs have a fatal flawRichard Damon
  |            | `* The Halting Problem proofs have a fatal flawolcott
  |            |  `- The Halting Problem proofs have a fatal flawRichard Damon
  |            `* The Halting Problem proofs have a fatal flawolcott
  |             `* The Halting Problem proofs have a fatal flawRichard Damon
  |              `* The Halting Problem proofs have a fatal flawolcott
  |               `* The Halting Problem proofs have a fatal flawRichard Damon
  |                `* The Halting Problem proofs have a fatal flawolcott
  |                 `* The Halting Problem proofs have a fatal flawRichard Damon
  |                  `* The Halting Problem proofs have a fatal flawolcott
  |                   `* The Halting Problem proofs have a fatal flawRichard Damon
  |                    `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                     `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                      `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                       `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                        `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                         `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                          `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                           `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                            `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                             `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                              `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                               `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                 `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                  `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                   `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                    `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                     `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                      `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                       `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                        `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                         `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                          `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                           `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                            `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                             `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                              `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                               `* The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  |                                                `* The Halting Problem proofs have a fatal flaw [ Visual Studioolcott
  |                                                 `- The Halting Problem proofs have a fatal flaw [ Visual StudioRichard Damon
  `* representing binary number naturally [The Halting Problem proofsPaul N
   `* representing binary number naturally [The Halting Problem proofsolcott
    `- representing binary number naturally [The Halting ProblemMr Flibble

Pages:123
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th2n07$fgth$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 18:56:54 -0500
Organization: A noiseless patient Spider
Lines: 349
Message-ID: <th2n07$fgth$1@dont-email.me>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgthrr$1rdj$1@gioia.aioe.org> <C8sYK.918322$%fx6.826267@fx14.ams1>
<tgtjg9$bor$1@gioia.aioe.org> <sEsYK.1635575$ulh3.952349@fx06.ams1>
<tgtmhj$3v66k$1@dont-email.me> <f8tYK.543903$wkZ5.502025@fx11.ams1>
<tgtntf$3v66k$3@dont-email.me> <8FtYK.699498$%q2.43782@fx15.ams1>
<tgtp7j$5p8$1@gioia.aioe.org> <o6uYK.242772$YVsf.228210@fx01.ams1>
<tgtrs5$rgq$1@gioia.aioe.org> <%IAYK.567410$YC96.259830@fx12.ams1>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Sep 2022 23:56:56 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="c6b266099a50a65dccd1a525d17cc3b3";
logging-data="508849"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19VbYcJjlaBEaG+LR34Knf6"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
Cancel-Lock: sha1:VbBfGU4m5NgqkO7QckDkESmI/5c=
Content-Language: en-US
In-Reply-To: <AU4ZK.110024$tRy7.104864@fx36.iad>
 by: olcott - Wed, 28 Sep 2022 23:56 UTC

On 9/28/2022 6:37 PM, Richard Damon wrote:
> On 9/28/22 7:31 PM, olcott wrote:
>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>> On 9/28/22 11:44 AM, olcott wrote:
>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz Kylheku
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not the place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a fair and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me before
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I could point out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you relied on for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value from H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is based
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for P to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs contained within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again and again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive and yet you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof does it state that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature BECAUSE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H IS NOT SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides mine)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the idea of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (SHD) ever thought all the way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus *ITS* simulation does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> define the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input is its actual behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That H correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never stops running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted conclusively proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this correctly simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state in 1 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ∞ steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> asking for is the behavior of the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bothered to think the application of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider is to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide on the behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes earlier
>>>>>>>>>>>>>>>>>>>>>>>>>> ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies that
>>>>>>>>>>>>>>>>>>>>>>>>>> the correct simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>> the underlying machine whenever any simulating
>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct on
>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material difference
>>>>>>>>>>>>>>>>>>>>>>>> between the two, that would seem to prove that
>>>>>>>>>>>>>>>>>>>>>>>> you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of a
>>>>>>>>>>>>>>>>>>>>>>> non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating: (unless
>>>>>>>>>>>>>>>>>>>>>> their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is aborted"
>>>>>>>>>>>>>>>>>>>>> but your defiition of H DOES abort its simulation,
>>>>>>>>>>>>>>>>>>>>> thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we replace H
>>>>>>>>>>>>>>>>>>>>>> with a UTM.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that it is.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the behavior
>>>>>>>>>>>>>>>>>>>> of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1 to ∞
>>>>>>>>>>>>>>>>>> simulated steps of P.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns 0,
>>>>>>>>>>>>>>>>> then P(P) will Halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar for the
>>>>>>>>>>>>>>>> 500th time*
>>>>>>>>>>>>>>>> *You know that you are not referring to the behavior of
>>>>>>>>>>>>>>>> an input to H*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P), or
>>>>>>>>>>>>>>> your P isn't the required "impossible Program".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>> correct simulation of this input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>
>>>>>>>>>>>> So like I said you have no source, you and most other are
>>>>>>>>>>>> only going by learned-by-rote so when a new issue comes up
>>>>>>>>>>>> your flounder. The others here not going by learned-by-rote
>>>>>>>>>>>> are going by total cluelessness.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> What about the Linz definition of a Halt Decider, the one YOU
>>>>>>>>>>> quote.
>>>>>>>>>>
>>>>>>>>>> He does not say that the correct simulation of an input does
>>>>>>>>>> not provide the actual behavior of this input. You will find
>>>>>>>>>> no competent person that will disagree with me on this point.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But he DOES say that the DEFINITION of the right answer is the
>>>>>>>>> behavior of the machine that input describes, so THAT is the
>>>>>>>>> behavior that counts.
>>>>>>>>>
>>>>>>>> People that know these things more deeply than learned-by-rote
>>>>>>>> will understand that my alternative definition is sound.
>>>>>>>
>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>
>>>>>>> That is like saying Two is the right answer to the question of
>>>>>>> How many cats you have, when you have one cats and one dog,
>>>>>>> because dogs are really pretty much like a cat.
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>>>
>>>>>>>> We can know that it is sound by simply knowing that the correct
>>>>>>>> simulation of the input does provide the actual behavior of this
>>>>>>>> input. We know this on the basis of the definition of a UTM.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>
>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>
>>>>>>> That is like getting off the highway at the second exit, well
>>>>>>> before you get into the city, and announce that traffic is clear
>>>>>>> into the city, because you didn't see any traffic.
>>>>>>>
>>>>>>> You are just PROVING our stupidity.
>>>>>>
>>>>>> Mike already corrected you on this.
>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>> computationally equivalent to the direct execution of 1 to ∞ steps
>>>>>> of the input.
>>>>>>
>>>>>> How can you disagree with this besides lying?
>>>>>>
>>>>>>
>>>>>
>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>
>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>
>>>>> You only "correctly simulate" a given input once, for a single
>>>>> number between 1 and infinity, so you never have a valuation of 1
>>>>> to infinite steps for any input except those that are basd on an Hx
>>>>> that never stops them, and thos Hx never abort.
>>>>>
>>>>
>>>> You cannot find a competent source that agrees that the actual
>>>> behavior of the input is not provided by the correct simulation of
>>>> this input therefore
>>>>
>>>
>>> Except that the problem is that "Correct Simulation" is generally
>>> taken to be a Correct and Complete Simulation,
>>
>> *No it is not and Mike already corrected you on this*
>> You stubbornly insistent on lying.
>
> The ONLY definition of "simulation" for Turing Machines that I know of
> is the UTM, and it only does a complete simulation of its input.
>
> Care to provide a reliable source that defines a "Correct Simulation" as
> to include a partial one that is applicable here?


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<gw5ZK.203513$elEa.38758@fx09.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<C8sYK.918322$%fx6.826267@fx14.ams1> <tgtjg9$bor$1@gioia.aioe.org>
<sEsYK.1635575$ulh3.952349@fx06.ams1> <tgtmhj$3v66k$1@dont-email.me>
<f8tYK.543903$wkZ5.502025@fx11.ams1> <tgtntf$3v66k$3@dont-email.me>
<8FtYK.699498$%q2.43782@fx15.ams1> <tgtp7j$5p8$1@gioia.aioe.org>
<o6uYK.242772$YVsf.228210@fx01.ams1> <tgtrs5$rgq$1@gioia.aioe.org>
<%IAYK.567410$YC96.259830@fx12.ams1> <tgv4ah$3a6r$2@dont-email.me>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th2n07$fgth$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 372
Message-ID: <gw5ZK.203513$elEa.38758@fx09.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, 28 Sep 2022 20:19:23 -0400
X-Received-Bytes: 21173
 by: Richard Damon - Thu, 29 Sep 2022 00:19 UTC

On 9/28/22 7:56 PM, olcott wrote:
> On 9/28/2022 6:37 PM, Richard Damon wrote:
>> On 9/28/22 7:31 PM, olcott wrote:
>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not the place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a fair
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and honest review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me before
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I could point out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you relied on for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value from H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for P to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again and again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive and yet you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof does it state that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO EXECUTE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mine) is the idea of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider (SHD) ever thought all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus *ITS* simulation does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> define the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input is its actual behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That H correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never stops running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted conclusively proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this correctly simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state in 1 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ∞ steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> asking for is the behavior of the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bothered to think the application of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider is to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide on the behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes earlier
>>>>>>>>>>>>>>>>>>>>>>>>>>> ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies
>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>> the underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite simulation it
>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct on
>>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material difference
>>>>>>>>>>>>>>>>>>>>>>>>> between the two, that would seem to prove that
>>>>>>>>>>>>>>>>>>>>>>>>> you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of a
>>>>>>>>>>>>>>>>>>>>>>>> non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates
>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating: (unless
>>>>>>>>>>>>>>>>>>>>>>> their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is aborted"
>>>>>>>>>>>>>>>>>>>>>> but your defiition of H DOES abort its simulation,
>>>>>>>>>>>>>>>>>>>>>> thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we replace H
>>>>>>>>>>>>>>>>>>>>>>> with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that it is.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1 to
>>>>>>>>>>>>>>>>>>> ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns 0,
>>>>>>>>>>>>>>>>>> then P(P) will Halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar for
>>>>>>>>>>>>>>>>> the 500th time*
>>>>>>>>>>>>>>>>> *You know that you are not referring to the behavior of
>>>>>>>>>>>>>>>>> an input to H*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P), or
>>>>>>>>>>>>>>>> your P isn't the required "impossible Program".
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>>> correct simulation of this input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> So like I said you have no source, you and most other are
>>>>>>>>>>>>> only going by learned-by-rote so when a new issue comes up
>>>>>>>>>>>>> your flounder. The others here not going by learned-by-rote
>>>>>>>>>>>>> are going by total cluelessness.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the one
>>>>>>>>>>>> YOU quote.
>>>>>>>>>>>
>>>>>>>>>>> He does not say that the correct simulation of an input does
>>>>>>>>>>> not provide the actual behavior of this input. You will find
>>>>>>>>>>> no competent person that will disagree with me on this point.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But he DOES say that the DEFINITION of the right answer is the
>>>>>>>>>> behavior of the machine that input describes, so THAT is the
>>>>>>>>>> behavior that counts.
>>>>>>>>>>
>>>>>>>>> People that know these things more deeply than learned-by-rote
>>>>>>>>> will understand that my alternative definition is sound.
>>>>>>>>
>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>
>>>>>>>> That is like saying Two is the right answer to the question of
>>>>>>>> How many cats you have, when you have one cats and one dog,
>>>>>>>> because dogs are really pretty much like a cat.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> We can know that it is sound by simply knowing that the correct
>>>>>>>>> simulation of the input does provide the actual behavior of
>>>>>>>>> this input. We know this on the basis of the definition of a UTM.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>
>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>
>>>>>>>> That is like getting off the highway at the second exit, well
>>>>>>>> before you get into the city, and announce that traffic is clear
>>>>>>>> into the city, because you didn't see any traffic.
>>>>>>>>
>>>>>>>> You are just PROVING our stupidity.
>>>>>>>
>>>>>>> Mike already corrected you on this.
>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>> computationally equivalent to the direct execution of 1 to ∞
>>>>>>> steps of the input.
>>>>>>>
>>>>>>> How can you disagree with this besides lying?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>
>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>
>>>>>> You only "correctly simulate" a given input once, for a single
>>>>>> number between 1 and infinity, so you never have a valuation of 1
>>>>>> to infinite steps for any input except those that are basd on an
>>>>>> Hx that never stops them, and thos Hx never abort.
>>>>>>
>>>>>
>>>>> You cannot find a competent source that agrees that the actual
>>>>> behavior of the input is not provided by the correct simulation of
>>>>> this input therefore
>>>>>
>>>>
>>>> Except that the problem is that "Correct Simulation" is generally
>>>> taken to be a Correct and Complete Simulation,
>>>
>>> *No it is not and Mike already corrected you on this*
>>> You stubbornly insistent on lying.
>>
>> The ONLY definition of "simulation" for Turing Machines that I know of
>> is the UTM, and it only does a complete simulation of its input.
>>
>> Care to provide a reliable source that defines a "Correct Simulation"
>> as to include a partial one that is applicable here?
>
> If you weren't a despicable lying bastard you would already acknowledge
> that 1 to ∞ simulated steps of a machine description is necessarily
> computationally equivalent to a corresponding 1 to ∞ steps of direct
> execution.
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th2onr$fgth$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 19:26:34 -0500
Organization: A noiseless patient Spider
Lines: 388
Message-ID: <th2onr$fgth$2@dont-email.me>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgtjg9$bor$1@gioia.aioe.org> <sEsYK.1635575$ulh3.952349@fx06.ams1>
<tgtmhj$3v66k$1@dont-email.me> <f8tYK.543903$wkZ5.502025@fx11.ams1>
<tgtntf$3v66k$3@dont-email.me> <8FtYK.699498$%q2.43782@fx15.ams1>
<tgtp7j$5p8$1@gioia.aioe.org> <o6uYK.242772$YVsf.228210@fx01.ams1>
<tgtrs5$rgq$1@gioia.aioe.org> <%IAYK.567410$YC96.259830@fx12.ams1>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
<th2n07$fgth$1@dont-email.me> <gw5ZK.203513$elEa.38758@fx09.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 29 Sep 2022 00:26:35 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="c6b266099a50a65dccd1a525d17cc3b3";
logging-data="508849"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+Me50XaHh9coptEiaAtGy+"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
Cancel-Lock: sha1:bTqStcdi8UKn3FFa79WSd/11gtg=
Content-Language: en-US
In-Reply-To: <gw5ZK.203513$elEa.38758@fx09.iad>
 by: olcott - Thu, 29 Sep 2022 00:26 UTC

On 9/28/2022 7:19 PM, Richard Damon wrote:
> On 9/28/22 7:56 PM, olcott wrote:
>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>> On 9/28/22 7:31 PM, olcott wrote:
>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not the place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a fair
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and honest review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value from H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to do the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again and again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive and yet you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof does it state that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mine) is the idea of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider (SHD) ever thought all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to report that this input does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus *ITS* simulation does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> define the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input is its actual behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That H correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never stops running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in 1 to ∞ steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> asking for is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bothered to think the application of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider all the way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to decide on the behavior of the Actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes earlier
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite simulation it
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct on
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would seem to
>>>>>>>>>>>>>>>>>>>>>>>>>> prove that you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of a
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates
>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating: (unless
>>>>>>>>>>>>>>>>>>>>>>>> their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort its
>>>>>>>>>>>>>>>>>>>>>>> simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we replace
>>>>>>>>>>>>>>>>>>>>>>>> H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that it
>>>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1 to
>>>>>>>>>>>>>>>>>>>> ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns 0,
>>>>>>>>>>>>>>>>>>> then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar for
>>>>>>>>>>>>>>>>>> the 500th time*
>>>>>>>>>>>>>>>>>> *You know that you are not referring to the behavior
>>>>>>>>>>>>>>>>>> of an input to H*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P), or
>>>>>>>>>>>>>>>>> your P isn't the required "impossible Program".
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>>>> correct simulation of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So like I said you have no source, you and most other are
>>>>>>>>>>>>>> only going by learned-by-rote so when a new issue comes up
>>>>>>>>>>>>>> your flounder. The others here not going by
>>>>>>>>>>>>>> learned-by-rote are going by total cluelessness.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the one
>>>>>>>>>>>>> YOU quote.
>>>>>>>>>>>>
>>>>>>>>>>>> He does not say that the correct simulation of an input does
>>>>>>>>>>>> not provide the actual behavior of this input. You will find
>>>>>>>>>>>> no competent person that will disagree with me on this point.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer is
>>>>>>>>>>> the behavior of the machine that input describes, so THAT is
>>>>>>>>>>> the behavior that counts.
>>>>>>>>>>>
>>>>>>>>>> People that know these things more deeply than learned-by-rote
>>>>>>>>>> will understand that my alternative definition is sound.
>>>>>>>>>
>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>
>>>>>>>>> That is like saying Two is the right answer to the question of
>>>>>>>>> How many cats you have, when you have one cats and one dog,
>>>>>>>>> because dogs are really pretty much like a cat.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>> definition of a UTM.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>
>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>
>>>>>>>>> That is like getting off the highway at the second exit, well
>>>>>>>>> before you get into the city, and announce that traffic is
>>>>>>>>> clear into the city, because you didn't see any traffic.
>>>>>>>>>
>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>
>>>>>>>> Mike already corrected you on this.
>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>> computationally equivalent to the direct execution of 1 to ∞
>>>>>>>> steps of the input.
>>>>>>>>
>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>
>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>
>>>>>>> You only "correctly simulate" a given input once, for a single
>>>>>>> number between 1 and infinity, so you never have a valuation of 1
>>>>>>> to infinite steps for any input except those that are basd on an
>>>>>>> Hx that never stops them, and thos Hx never abort.
>>>>>>>
>>>>>>
>>>>>> You cannot find a competent source that agrees that the actual
>>>>>> behavior of the input is not provided by the correct simulation of
>>>>>> this input therefore
>>>>>>
>>>>>
>>>>> Except that the problem is that "Correct Simulation" is generally
>>>>> taken to be a Correct and Complete Simulation,
>>>>
>>>> *No it is not and Mike already corrected you on this*
>>>> You stubbornly insistent on lying.
>>>
>>> The ONLY definition of "simulation" for Turing Machines that I know
>>> of is the UTM, and it only does a complete simulation of its input.
>>>
>>> Care to provide a reliable source that defines a "Correct Simulation"
>>> as to include a partial one that is applicable here?
>>
>> If you weren't a despicable lying bastard you would already
>> acknowledge that 1 to ∞ simulated steps of a machine description is
>> necessarily computationally equivalent to a corresponding 1 to ∞ steps
>> of direct execution.
>>
>
> Infinite steps, or more steps than it takes to reach the final state, yes.
>
On 9/28/2022 6:56 PM, olcott wrote:
> *If you weren't a despicable lying bastard* you would
> already acknowledge that 1 to ∞ simulated steps of
> a machine description is necessarily computationally
> equivalent to a corresponding 1 to ∞ steps of direct
> execution.
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<A36ZK.187925$IRd5.90886@fx10.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<sEsYK.1635575$ulh3.952349@fx06.ams1> <tgtmhj$3v66k$1@dont-email.me>
<f8tYK.543903$wkZ5.502025@fx11.ams1> <tgtntf$3v66k$3@dont-email.me>
<8FtYK.699498$%q2.43782@fx15.ams1> <tgtp7j$5p8$1@gioia.aioe.org>
<o6uYK.242772$YVsf.228210@fx01.ams1> <tgtrs5$rgq$1@gioia.aioe.org>
<%IAYK.567410$YC96.259830@fx12.ams1> <tgv4ah$3a6r$2@dont-email.me>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
<gw5ZK.203513$elEa.38758@fx09.iad> <th2onr$fgth$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th2onr$fgth$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 396
Message-ID: <A36ZK.187925$IRd5.90886@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Sep 2022 20:57:03 -0400
X-Received-Bytes: 22406
 by: Richard Damon - Thu, 29 Sep 2022 00:57 UTC

On 9/28/22 8:26 PM, olcott wrote:
> On 9/28/2022 7:19 PM, Richard Damon wrote:
>> On 9/28/22 7:56 PM, olcott wrote:
>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not the place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a fair
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and honest review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value from H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to do the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again and again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't recursive and yet you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof does it state that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mine) is the idea of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider (SHD) ever thought all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, and thus *ITS* simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not define the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior. That H correctly predicts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correct simulation never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state in 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is asking for is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever bothered to think the application
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a simulating halt decider all the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to decide on the behavior of the Actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes earlier
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would seem
>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove that you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of a
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating: (unless
>>>>>>>>>>>>>>>>>>>>>>>>> their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort its
>>>>>>>>>>>>>>>>>>>>>>>> simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we replace
>>>>>>>>>>>>>>>>>>>>>>>>> H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that
>>>>>>>>>>>>>>>>>>>>>>>> it is.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1
>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns 0,
>>>>>>>>>>>>>>>>>>>> then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar for
>>>>>>>>>>>>>>>>>>> the 500th time*
>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the behavior
>>>>>>>>>>>>>>>>>>> of an input to H*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P),
>>>>>>>>>>>>>>>>>> or your P isn't the required "impossible Program".
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>>>>> correct simulation of this input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So like I said you have no source, you and most other are
>>>>>>>>>>>>>>> only going by learned-by-rote so when a new issue comes
>>>>>>>>>>>>>>> up your flounder. The others here not going by
>>>>>>>>>>>>>>> learned-by-rote are going by total cluelessness.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the one
>>>>>>>>>>>>>> YOU quote.
>>>>>>>>>>>>>
>>>>>>>>>>>>> He does not say that the correct simulation of an input
>>>>>>>>>>>>> does not provide the actual behavior of this input. You
>>>>>>>>>>>>> will find no competent person that will disagree with me on
>>>>>>>>>>>>> this point.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer is
>>>>>>>>>>>> the behavior of the machine that input describes, so THAT is
>>>>>>>>>>>> the behavior that counts.
>>>>>>>>>>>>
>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>> definition is sound.
>>>>>>>>>>
>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>
>>>>>>>>>> That is like saying Two is the right answer to the question of
>>>>>>>>>> How many cats you have, when you have one cats and one dog,
>>>>>>>>>> because dogs are really pretty much like a cat.
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>
>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>
>>>>>>>>>> That is like getting off the highway at the second exit, well
>>>>>>>>>> before you get into the city, and announce that traffic is
>>>>>>>>>> clear into the city, because you didn't see any traffic.
>>>>>>>>>>
>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>
>>>>>>>>> Mike already corrected you on this.
>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>> computationally equivalent to the direct execution of 1 to ∞
>>>>>>>>> steps of the input.
>>>>>>>>>
>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>
>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>
>>>>>>>> You only "correctly simulate" a given input once, for a single
>>>>>>>> number between 1 and infinity, so you never have a valuation of
>>>>>>>> 1 to infinite steps for any input except those that are basd on
>>>>>>>> an Hx that never stops them, and thos Hx never abort.
>>>>>>>>
>>>>>>>
>>>>>>> You cannot find a competent source that agrees that the actual
>>>>>>> behavior of the input is not provided by the correct simulation
>>>>>>> of this input therefore
>>>>>>>
>>>>>>
>>>>>> Except that the problem is that "Correct Simulation" is generally
>>>>>> taken to be a Correct and Complete Simulation,
>>>>>
>>>>> *No it is not and Mike already corrected you on this*
>>>>> You stubbornly insistent on lying.
>>>>
>>>> The ONLY definition of "simulation" for Turing Machines that I know
>>>> of is the UTM, and it only does a complete simulation of its input.
>>>>
>>>> Care to provide a reliable source that defines a "Correct
>>>> Simulation" as to include a partial one that is applicable here?
>>>
>>> If you weren't a despicable lying bastard you would already
>>> acknowledge that 1 to ∞ simulated steps of a machine description is
>>> necessarily computationally equivalent to a corresponding 1 to ∞
>>> steps of direct execution.
>>>
>>
>> Infinite steps, or more steps than it takes to reach the final state,
>> yes.
>>
> On 9/28/2022 6:56 PM, olcott wrote:
> > *If you weren't a despicable lying bastard* you would
> > already acknowledge that 1 to ∞ simulated steps of
> > a machine description is necessarily computationally
> > equivalent to a corresponding 1 to ∞ steps of direct
> > execution.
> >
>
> *The problem is that you are a despicable lying bastard*
> Trying to pretend that you didn't see
>
> 1 to ∞ simulated steps
> 1 to ∞ simulated steps
> 1 to ∞ simulated steps
> 1 to ∞ simulated steps
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th2r02$flk6$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 20:05:04 -0500
Organization: A noiseless patient Spider
Lines: 412
Message-ID: <th2r02$flk6$1@dont-email.me>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgtmhj$3v66k$1@dont-email.me> <f8tYK.543903$wkZ5.502025@fx11.ams1>
<tgtntf$3v66k$3@dont-email.me> <8FtYK.699498$%q2.43782@fx15.ams1>
<tgtp7j$5p8$1@gioia.aioe.org> <o6uYK.242772$YVsf.228210@fx01.ams1>
<tgtrs5$rgq$1@gioia.aioe.org> <%IAYK.567410$YC96.259830@fx12.ams1>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
<th2n07$fgth$1@dont-email.me> <gw5ZK.203513$elEa.38758@fx09.iad>
<th2onr$fgth$2@dont-email.me> <A36ZK.187925$IRd5.90886@fx10.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 29 Sep 2022 01:05:06 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="c6b266099a50a65dccd1a525d17cc3b3";
logging-data="513670"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/fotefOGjrGeYMQ4oz2yjI"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
Cancel-Lock: sha1:C89SBuh2Itm7PiE5/tK8u6PMCvU=
In-Reply-To: <A36ZK.187925$IRd5.90886@fx10.iad>
Content-Language: en-US
 by: olcott - Thu, 29 Sep 2022 01:05 UTC

On 9/28/2022 7:57 PM, Richard Damon wrote:
> On 9/28/22 8:26 PM, olcott wrote:
>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>> On 9/28/22 7:56 PM, olcott wrote:
>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not the place to discuss
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a fair
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and honest review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to do the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again. H IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't recursive and yet you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mine) is the idea of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider (SHD) ever thought
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent infinite simulation it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, and thus *ITS* simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not define the "behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that its correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state in 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is asking for is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever bothered to think the application
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a simulating halt decider all the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to decide on the behavior of the Actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes earlier
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of the meaning of its words
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would seem
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove that you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>> a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating: (unless
>>>>>>>>>>>>>>>>>>>>>>>>>> their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that
>>>>>>>>>>>>>>>>>>>>>>>>> it is.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1
>>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns 0,
>>>>>>>>>>>>>>>>>>>>> then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar for
>>>>>>>>>>>>>>>>>>>> the 500th time*
>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the behavior
>>>>>>>>>>>>>>>>>>>> of an input to H*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P),
>>>>>>>>>>>>>>>>>>> or your P isn't the required "impossible Program".
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that
>>>>>>>>>>>>>>>>>> the actual behavior of the input is not provided by
>>>>>>>>>>>>>>>>>> the correct simulation of this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So like I said you have no source, you and most other
>>>>>>>>>>>>>>>> are only going by learned-by-rote so when a new issue
>>>>>>>>>>>>>>>> comes up your flounder. The others here not going by
>>>>>>>>>>>>>>>> learned-by-rote are going by total cluelessness.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the one
>>>>>>>>>>>>>>> YOU quote.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> He does not say that the correct simulation of an input
>>>>>>>>>>>>>> does not provide the actual behavior of this input. You
>>>>>>>>>>>>>> will find no competent person that will disagree with me
>>>>>>>>>>>>>> on this point.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer is
>>>>>>>>>>>>> the behavior of the machine that input describes, so THAT
>>>>>>>>>>>>> is the behavior that counts.
>>>>>>>>>>>>>
>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>
>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>
>>>>>>>>>>> That is like saying Two is the right answer to the question
>>>>>>>>>>> of How many cats you have, when you have one cats and one
>>>>>>>>>>> dog, because dogs are really pretty much like a cat.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>
>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>
>>>>>>>>>>> That is like getting off the highway at the second exit, well
>>>>>>>>>>> before you get into the city, and announce that traffic is
>>>>>>>>>>> clear into the city, because you didn't see any traffic.
>>>>>>>>>>>
>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>
>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>> computationally equivalent to the direct execution of 1 to ∞
>>>>>>>>>> steps of the input.
>>>>>>>>>>
>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>
>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>
>>>>>>>>> You only "correctly simulate" a given input once, for a single
>>>>>>>>> number between 1 and infinity, so you never have a valuation of
>>>>>>>>> 1 to infinite steps for any input except those that are basd on
>>>>>>>>> an Hx that never stops them, and thos Hx never abort.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You cannot find a competent source that agrees that the actual
>>>>>>>> behavior of the input is not provided by the correct simulation
>>>>>>>> of this input therefore
>>>>>>>>
>>>>>>>
>>>>>>> Except that the problem is that "Correct Simulation" is generally
>>>>>>> taken to be a Correct and Complete Simulation,
>>>>>>
>>>>>> *No it is not and Mike already corrected you on this*
>>>>>> You stubbornly insistent on lying.
>>>>>
>>>>> The ONLY definition of "simulation" for Turing Machines that I know
>>>>> of is the UTM, and it only does a complete simulation of its input.
>>>>>
>>>>> Care to provide a reliable source that defines a "Correct
>>>>> Simulation" as to include a partial one that is applicable here?
>>>>
>>>> If you weren't a despicable lying bastard you would already
>>>> acknowledge that 1 to ∞ simulated steps of a machine description is
>>>> necessarily computationally equivalent to a corresponding 1 to ∞
>>>> steps of direct execution.
>>>>
>>>
>>> Infinite steps, or more steps than it takes to reach the final state,
>>> yes.
>>>
>> On 9/28/2022 6:56 PM, olcott wrote:
>>  > *If you weren't a despicable lying bastard* you would
>>  > already acknowledge that 1 to ∞ simulated steps of
>>  > a machine description is necessarily computationally
>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>  > execution.
>>  >
>>
>> *The problem is that you are a despicable lying bastard*
>> Trying to pretend that you didn't see
>>
>> 1 to ∞ simulated steps
>> 1 to ∞ simulated steps
>> 1 to ∞ simulated steps
>> 1 to ∞ simulated steps
>>
>
> So ARE you claiming that all the Px are the same input, and thus the
> behavior of Px doesn't depend on the Hx it calls?
>
None of the Px elements of the infinite set of Hx/Px pairs reaches its
final state and halts when 1 to ∞ steps of Px are simulated (or directly
executed) by some Hx.


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<nt6ZK.24903$C8y5.3770@fx07.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx07.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<f8tYK.543903$wkZ5.502025@fx11.ams1> <tgtntf$3v66k$3@dont-email.me>
<8FtYK.699498$%q2.43782@fx15.ams1> <tgtp7j$5p8$1@gioia.aioe.org>
<o6uYK.242772$YVsf.228210@fx01.ams1> <tgtrs5$rgq$1@gioia.aioe.org>
<%IAYK.567410$YC96.259830@fx12.ams1> <tgv4ah$3a6r$2@dont-email.me>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
<gw5ZK.203513$elEa.38758@fx09.iad> <th2onr$fgth$2@dont-email.me>
<A36ZK.187925$IRd5.90886@fx10.iad> <th2r02$flk6$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th2r02$flk6$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 435
Message-ID: <nt6ZK.24903$C8y5.3770@fx07.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Sep 2022 21:24:34 -0400
X-Received-Bytes: 24889
 by: Richard Damon - Thu, 29 Sep 2022 01:24 UTC

On 9/28/22 9:05 PM, olcott wrote:
> On 9/28/2022 7:57 PM, Richard Damon wrote:
>> On 9/28/22 8:26 PM, olcott wrote:
>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not the place to discuss
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fair and honest review I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P to do the opposite of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again. H IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't recursive and yet you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mine) is the idea of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider (SHD) ever thought
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, and thus *ITS* simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not define the "behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that its correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its own final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state in 1 to ∞ steps of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is asking for is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is to decide on the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of the meaning of its words
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would seem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove that you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort
>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that
>>>>>>>>>>>>>>>>>>>>>>>>>> it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1
>>>>>>>>>>>>>>>>>>>>>>> to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns
>>>>>>>>>>>>>>>>>>>>>> 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar
>>>>>>>>>>>>>>>>>>>>> for the 500th time*
>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P),
>>>>>>>>>>>>>>>>>>>> or your P isn't the required "impossible Program".
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that
>>>>>>>>>>>>>>>>>>> the actual behavior of the input is not provided by
>>>>>>>>>>>>>>>>>>> the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So like I said you have no source, you and most other
>>>>>>>>>>>>>>>>> are only going by learned-by-rote so when a new issue
>>>>>>>>>>>>>>>>> comes up your flounder. The others here not going by
>>>>>>>>>>>>>>>>> learned-by-rote are going by total cluelessness.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the
>>>>>>>>>>>>>>>> one YOU quote.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> He does not say that the correct simulation of an input
>>>>>>>>>>>>>>> does not provide the actual behavior of this input. You
>>>>>>>>>>>>>>> will find no competent person that will disagree with me
>>>>>>>>>>>>>>> on this point.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer is
>>>>>>>>>>>>>> the behavior of the machine that input describes, so THAT
>>>>>>>>>>>>>> is the behavior that counts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>
>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>
>>>>>>>>>>>> That is like saying Two is the right answer to the question
>>>>>>>>>>>> of How many cats you have, when you have one cats and one
>>>>>>>>>>>> dog, because dogs are really pretty much like a cat.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>
>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>
>>>>>>>>>>>> That is like getting off the highway at the second exit,
>>>>>>>>>>>> well before you get into the city, and announce that traffic
>>>>>>>>>>>> is clear into the city, because you didn't see any traffic.
>>>>>>>>>>>>
>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>
>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>>> computationally equivalent to the direct execution of 1 to ∞
>>>>>>>>>>> steps of the input.
>>>>>>>>>>>
>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>
>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>
>>>>>>>>>> You only "correctly simulate" a given input once, for a single
>>>>>>>>>> number between 1 and infinity, so you never have a valuation
>>>>>>>>>> of 1 to infinite steps for any input except those that are
>>>>>>>>>> basd on an Hx that never stops them, and thos Hx never abort.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You cannot find a competent source that agrees that the actual
>>>>>>>>> behavior of the input is not provided by the correct simulation
>>>>>>>>> of this input therefore
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>
>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>> You stubbornly insistent on lying.
>>>>>>
>>>>>> The ONLY definition of "simulation" for Turing Machines that I
>>>>>> know of is the UTM, and it only does a complete simulation of its
>>>>>> input.
>>>>>>
>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>> Simulation" as to include a partial one that is applicable here?
>>>>>
>>>>> If you weren't a despicable lying bastard you would already
>>>>> acknowledge that 1 to ∞ simulated steps of a machine description is
>>>>> necessarily computationally equivalent to a corresponding 1 to ∞
>>>>> steps of direct execution.
>>>>>
>>>>
>>>> Infinite steps, or more steps than it takes to reach the final
>>>> state, yes.
>>>>
>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>  > *If you weren't a despicable lying bastard* you would
>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>  > a machine description is necessarily computationally
>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>  > execution.
>>>  >
>>>
>>> *The problem is that you are a despicable lying bastard*
>>> Trying to pretend that you didn't see
>>>
>>> 1 to ∞ simulated steps
>>> 1 to ∞ simulated steps
>>> 1 to ∞ simulated steps
>>> 1 to ∞ simulated steps
>>>
>>
>> So ARE you claiming that all the Px are the same input, and thus the
>> behavior of Px doesn't depend on the Hx it calls?
>>
> None of the Px elements of the infinite set of Hx/Px pairs reaches its
> final state and halts when 1 to ∞ steps of Px are simulated (or directly
> executed) by some Hx.
>
> This is enough for anyone with sufficient technical competence that is
> not a despicable lying bastard to acknowledge that Px is non-halting.
>
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th2v0b$flk6$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 21:13:29 -0500
Organization: A noiseless patient Spider
Lines: 438
Message-ID: <th2v0b$flk6$2@dont-email.me>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgtntf$3v66k$3@dont-email.me> <8FtYK.699498$%q2.43782@fx15.ams1>
<tgtp7j$5p8$1@gioia.aioe.org> <o6uYK.242772$YVsf.228210@fx01.ams1>
<tgtrs5$rgq$1@gioia.aioe.org> <%IAYK.567410$YC96.259830@fx12.ams1>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
<th2n07$fgth$1@dont-email.me> <gw5ZK.203513$elEa.38758@fx09.iad>
<th2onr$fgth$2@dont-email.me> <A36ZK.187925$IRd5.90886@fx10.iad>
<th2r02$flk6$1@dont-email.me> <nt6ZK.24903$C8y5.3770@fx07.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 29 Sep 2022 02:13:31 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="c6b266099a50a65dccd1a525d17cc3b3";
logging-data="513670"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/87vMpsPBS1y1+13vKioew"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
Cancel-Lock: sha1:xFC7fjUhN5GmboXwuTszMTuCNIw=
Content-Language: en-US
In-Reply-To: <nt6ZK.24903$C8y5.3770@fx07.iad>
 by: olcott - Thu, 29 Sep 2022 02:13 UTC

On 9/28/2022 8:24 PM, Richard Damon wrote:
> On 9/28/22 9:05 PM, olcott wrote:
>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>> On 9/28/22 8:26 PM, olcott wrote:
>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will push you out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fair and honest review I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely proves that no value
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P to do the opposite of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their inputs contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again. H IS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't recursive and yet you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mine) is the idea of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever thought all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, and thus *ITS* simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not define the "behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that its correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state in 1 to ∞ steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is to decide on the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of the meaning of its words
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to prove that you are technically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume
>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>> 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns
>>>>>>>>>>>>>>>>>>>>>>> 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar
>>>>>>>>>>>>>>>>>>>>>> for the 500th time*
>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation
>>>>>>>>>>>>>>>>>>>>> P(P), or your P isn't the required "impossible
>>>>>>>>>>>>>>>>>>>>> Program".
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that
>>>>>>>>>>>>>>>>>>>> the actual behavior of the input is not provided by
>>>>>>>>>>>>>>>>>>>> the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most other
>>>>>>>>>>>>>>>>>> are only going by learned-by-rote so when a new issue
>>>>>>>>>>>>>>>>>> comes up your flounder. The others here not going by
>>>>>>>>>>>>>>>>>> learned-by-rote are going by total cluelessness.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the
>>>>>>>>>>>>>>>>> one YOU quote.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> He does not say that the correct simulation of an input
>>>>>>>>>>>>>>>> does not provide the actual behavior of this input. You
>>>>>>>>>>>>>>>> will find no competent person that will disagree with me
>>>>>>>>>>>>>>>> on this point.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer
>>>>>>>>>>>>>>> is the behavior of the machine that input describes, so
>>>>>>>>>>>>>>> THAT is the behavior that counts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is like saying Two is the right answer to the question
>>>>>>>>>>>>> of How many cats you have, when you have one cats and one
>>>>>>>>>>>>> dog, because dogs are really pretty much like a cat.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is like getting off the highway at the second exit,
>>>>>>>>>>>>> well before you get into the city, and announce that
>>>>>>>>>>>>> traffic is clear into the city, because you didn't see any
>>>>>>>>>>>>> traffic.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>
>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>>>> computationally equivalent to the direct execution of 1 to ∞
>>>>>>>>>>>> steps of the input.
>>>>>>>>>>>>
>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>
>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>
>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>> single number between 1 and infinity, so you never have a
>>>>>>>>>>> valuation of 1 to infinite steps for any input except those
>>>>>>>>>>> that are basd on an Hx that never stops them, and thos Hx
>>>>>>>>>>> never abort.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You cannot find a competent source that agrees that the actual
>>>>>>>>>> behavior of the input is not provided by the correct
>>>>>>>>>> simulation of this input therefore
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>
>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>> You stubbornly insistent on lying.
>>>>>>>
>>>>>>> The ONLY definition of "simulation" for Turing Machines that I
>>>>>>> know of is the UTM, and it only does a complete simulation of its
>>>>>>> input.
>>>>>>>
>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>> Simulation" as to include a partial one that is applicable here?
>>>>>>
>>>>>> If you weren't a despicable lying bastard you would already
>>>>>> acknowledge that 1 to ∞ simulated steps of a machine description
>>>>>> is necessarily computationally equivalent to a corresponding 1 to
>>>>>> ∞ steps of direct execution.
>>>>>>
>>>>>
>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>> state, yes.
>>>>>
>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>  > *If you weren't a despicable lying bastard* you would
>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>  > a machine description is necessarily computationally
>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>  > execution.
>>>>  >
>>>>
>>>> *The problem is that you are a despicable lying bastard*
>>>> Trying to pretend that you didn't see
>>>>
>>>> 1 to ∞ simulated steps
>>>> 1 to ∞ simulated steps
>>>> 1 to ∞ simulated steps
>>>> 1 to ∞ simulated steps
>>>>
>>>
>>> So ARE you claiming that all the Px are the same input, and thus the
>>> behavior of Px doesn't depend on the Hx it calls?
>>>
>> None of the Px elements of the infinite set of Hx/Px pairs reaches its
>> final state and halts when 1 to ∞ steps of Px are simulated (or
>> directly executed) by some Hx.
>>
>> This is enough for anyone with sufficient technical competence that is
>> not a despicable lying bastard to acknowledge that Px is non-halting.
>>
>>
>
> No, it isn't. An infinite number of incomplete answers does not add up
> to a correct answer.


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<Xm7ZK.236360$PRW4.73623@fx11.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<8FtYK.699498$%q2.43782@fx15.ams1> <tgtp7j$5p8$1@gioia.aioe.org>
<o6uYK.242772$YVsf.228210@fx01.ams1> <tgtrs5$rgq$1@gioia.aioe.org>
<%IAYK.567410$YC96.259830@fx12.ams1> <tgv4ah$3a6r$2@dont-email.me>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
<gw5ZK.203513$elEa.38758@fx09.iad> <th2onr$fgth$2@dont-email.me>
<A36ZK.187925$IRd5.90886@fx10.iad> <th2r02$flk6$1@dont-email.me>
<nt6ZK.24903$C8y5.3770@fx07.iad> <th2v0b$flk6$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th2v0b$flk6$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 471
Message-ID: <Xm7ZK.236360$PRW4.73623@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Sep 2022 22:25:59 -0400
X-Received-Bytes: 26935
 by: Richard Damon - Thu, 29 Sep 2022 02:25 UTC

On 9/28/22 10:13 PM, olcott wrote:
> On 9/28/2022 8:24 PM, Richard Damon wrote:
>> On 9/28/22 9:05 PM, olcott wrote:
>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will push you out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fair and honest review I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you relied on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is based on a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for P to do the opposite of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their inputs contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again. H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't recursive and yet you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the idea of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever thought all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at all how the decider got the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, and thus *ITS* simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not define the "behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that its correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that this correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state in 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is to decide on the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its words it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to prove that you are technically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>>>> 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns
>>>>>>>>>>>>>>>>>>>>>>>> 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar
>>>>>>>>>>>>>>>>>>>>>>> for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation
>>>>>>>>>>>>>>>>>>>>>> P(P), or your P isn't the required "impossible
>>>>>>>>>>>>>>>>>>>>>> Program".
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that
>>>>>>>>>>>>>>>>>>>>> the actual behavior of the input is not provided by
>>>>>>>>>>>>>>>>>>>>> the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most other
>>>>>>>>>>>>>>>>>>> are only going by learned-by-rote so when a new issue
>>>>>>>>>>>>>>>>>>> comes up your flounder. The others here not going by
>>>>>>>>>>>>>>>>>>> learned-by-rote are going by total cluelessness.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the
>>>>>>>>>>>>>>>>>> one YOU quote.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an input
>>>>>>>>>>>>>>>>> does not provide the actual behavior of this input. You
>>>>>>>>>>>>>>>>> will find no competent person that will disagree with
>>>>>>>>>>>>>>>>> me on this point.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer
>>>>>>>>>>>>>>>> is the behavior of the machine that input describes, so
>>>>>>>>>>>>>>>> THAT is the behavior that counts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>> question of How many cats you have, when you have one cats
>>>>>>>>>>>>>> and one dog, because dogs are really pretty much like a cat.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is like getting off the highway at the second exit,
>>>>>>>>>>>>>> well before you get into the city, and announce that
>>>>>>>>>>>>>> traffic is clear into the city, because you didn't see any
>>>>>>>>>>>>>> traffic.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>>>>> computationally equivalent to the direct execution of 1 to
>>>>>>>>>>>>> ∞ steps of the input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>
>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>
>>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>>> single number between 1 and infinity, so you never have a
>>>>>>>>>>>> valuation of 1 to infinite steps for any input except those
>>>>>>>>>>>> that are basd on an Hx that never stops them, and thos Hx
>>>>>>>>>>>> never abort.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>> actual behavior of the input is not provided by the correct
>>>>>>>>>>> simulation of this input therefore
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>
>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>
>>>>>>>> The ONLY definition of "simulation" for Turing Machines that I
>>>>>>>> know of is the UTM, and it only does a complete simulation of
>>>>>>>> its input.
>>>>>>>>
>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>> Simulation" as to include a partial one that is applicable here?
>>>>>>>
>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine description
>>>>>>> is necessarily computationally equivalent to a corresponding 1 to
>>>>>>> ∞ steps of direct execution.
>>>>>>>
>>>>>>
>>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>>> state, yes.
>>>>>>
>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>  > a machine description is necessarily computationally
>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>  > execution.
>>>>>  >
>>>>>
>>>>> *The problem is that you are a despicable lying bastard*
>>>>> Trying to pretend that you didn't see
>>>>>
>>>>> 1 to ∞ simulated steps
>>>>> 1 to ∞ simulated steps
>>>>> 1 to ∞ simulated steps
>>>>> 1 to ∞ simulated steps
>>>>>
>>>>
>>>> So ARE you claiming that all the Px are the same input, and thus the
>>>> behavior of Px doesn't depend on the Hx it calls?
>>>>
>>> None of the Px elements of the infinite set of Hx/Px pairs reaches
>>> its final state and halts when 1 to ∞ steps of Px are simulated (or
>>> directly executed) by some Hx.
>>>
>>> This is enough for anyone with sufficient technical competence that
>>> is not a despicable lying bastard to acknowledge that Px is non-halting.
>>>
>>>
>>
>> No, it isn't. An infinite number of incomplete answers does not add up
>> to a correct answer.
>
> Because you are a despicable lying bastard you change the subject to a
> different point before any point is ever made and validated.


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th3039$kmq$1@gioia.aioe.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!WLfZA/JXwj9HbHJM5fyP+A.user.46.165.242.91.POSTED!not-for-mail
From: none...@beez-waxes.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 21:32:07 -0500
Organization: Aioe.org NNTP Server
Message-ID: <th3039$kmq$1@gioia.aioe.org>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgtp7j$5p8$1@gioia.aioe.org> <o6uYK.242772$YVsf.228210@fx01.ams1>
<tgtrs5$rgq$1@gioia.aioe.org> <%IAYK.567410$YC96.259830@fx12.ams1>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
<th2n07$fgth$1@dont-email.me> <gw5ZK.203513$elEa.38758@fx09.iad>
<th2onr$fgth$2@dont-email.me> <A36ZK.187925$IRd5.90886@fx10.iad>
<th2r02$flk6$1@dont-email.me> <nt6ZK.24903$C8y5.3770@fx07.iad>
<th2v0b$flk6$2@dont-email.me> <Xm7ZK.236360$PRW4.73623@fx11.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="21210"; posting-host="WLfZA/JXwj9HbHJM5fyP+A.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: olcott - Thu, 29 Sep 2022 02:32 UTC

On 9/28/2022 9:25 PM, Richard Damon wrote:
> On 9/28/22 10:13 PM, olcott wrote:
>> On 9/28/2022 8:24 PM, Richard Damon wrote:
>>> On 9/28/22 9:05 PM, olcott wrote:
>>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will push you out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fair and honest review I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before I could point out
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you relied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly be correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is based on a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for P to do the opposite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their inputs contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again. H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't recursive and yet you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BECAUSE H IS NOT SUPPOSED TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the idea of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (SHD) ever thought all the way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at all how the decider got the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that this input does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM, and thus *ITS*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not define the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in 1 to ∞ steps of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider is to decide on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its words it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to prove that you are technically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation, thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ∞ correctly simulated steps, thus predict
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> of 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a liar
>>>>>>>>>>>>>>>>>>>>>>>> for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation
>>>>>>>>>>>>>>>>>>>>>>> P(P), or your P isn't the required "impossible
>>>>>>>>>>>>>>>>>>>>>>> Program".
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees
>>>>>>>>>>>>>>>>>>>>>> that the actual behavior of the input is not
>>>>>>>>>>>>>>>>>>>>>> provided by the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most
>>>>>>>>>>>>>>>>>>>> other are only going by learned-by-rote so when a
>>>>>>>>>>>>>>>>>>>> new issue comes up your flounder. The others here
>>>>>>>>>>>>>>>>>>>> not going by learned-by-rote are going by total
>>>>>>>>>>>>>>>>>>>> cluelessness.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider, the
>>>>>>>>>>>>>>>>>>> one YOU quote.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an
>>>>>>>>>>>>>>>>>> input does not provide the actual behavior of this
>>>>>>>>>>>>>>>>>> input. You will find no competent person that will
>>>>>>>>>>>>>>>>>> disagree with me on this point.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right answer
>>>>>>>>>>>>>>>>> is the behavior of the machine that input describes, so
>>>>>>>>>>>>>>>>> THAT is the behavior that counts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>>> question of How many cats you have, when you have one
>>>>>>>>>>>>>>> cats and one dog, because dogs are really pretty much
>>>>>>>>>>>>>>> like a cat.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>>>>>>> behavior of this input. We know this on the basis of the
>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is like getting off the highway at the second exit,
>>>>>>>>>>>>>>> well before you get into the city, and announce that
>>>>>>>>>>>>>>> traffic is clear into the city, because you didn't see
>>>>>>>>>>>>>>> any traffic.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>>>>>> computationally equivalent to the direct execution of 1 to
>>>>>>>>>>>>>> ∞ steps of the input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>>
>>>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>>>> single number between 1 and infinity, so you never have a
>>>>>>>>>>>>> valuation of 1 to infinite steps for any input except those
>>>>>>>>>>>>> that are basd on an Hx that never stops them, and thos Hx
>>>>>>>>>>>>> never abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>> actual behavior of the input is not provided by the correct
>>>>>>>>>>>> simulation of this input therefore
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>>
>>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>>
>>>>>>>>> The ONLY definition of "simulation" for Turing Machines that I
>>>>>>>>> know of is the UTM, and it only does a complete simulation of
>>>>>>>>> its input.
>>>>>>>>>
>>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>>> Simulation" as to include a partial one that is applicable here?
>>>>>>>>
>>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine description
>>>>>>>> is necessarily computationally equivalent to a corresponding 1
>>>>>>>> to ∞ steps of direct execution.
>>>>>>>>
>>>>>>>
>>>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>>>> state, yes.
>>>>>>>
>>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>>  > a machine description is necessarily computationally
>>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>>  > execution.
>>>>>>  >
>>>>>>
>>>>>> *The problem is that you are a despicable lying bastard*
>>>>>> Trying to pretend that you didn't see
>>>>>>
>>>>>> 1 to ∞ simulated steps
>>>>>> 1 to ∞ simulated steps
>>>>>> 1 to ∞ simulated steps
>>>>>> 1 to ∞ simulated steps
>>>>>>
>>>>>
>>>>> So ARE you claiming that all the Px are the same input, and thus
>>>>> the behavior of Px doesn't depend on the Hx it calls?
>>>>>
>>>> None of the Px elements of the infinite set of Hx/Px pairs reaches
>>>> its final state and halts when 1 to ∞ steps of Px are simulated (or
>>>> directly executed) by some Hx.
>>>>
>>>> This is enough for anyone with sufficient technical competence that
>>>> is not a despicable lying bastard to acknowledge that Px is
>>>> non-halting.
>>>>
>>>>
>>>
>>> No, it isn't. An infinite number of incomplete answers does not add
>>> up to a correct answer.
>>
>> Because you are a despicable lying bastard you change the subject to a
>> different point before any point is ever made and validated.
>
> No, I didn't/
>
>>
>> The only point being made here is that a correct simulation is not
>> required to be a complete simulation. If a single step is correctly
>> simulated then this single step is simulated correctly.
>>
>
> So, the single step being simulated correctly does NOT mean that the
> input was simulated correct.
>
Exactly what a despicable lying bastard would say.
That one step of an input is simulated correctly DOES MEAN
That one step of an input is simulated correctly.


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<Cw7ZK.221274$9Yp5.21321@fx12.iad>

  copy mid

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

  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!fx12.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<o6uYK.242772$YVsf.228210@fx01.ams1> <tgtrs5$rgq$1@gioia.aioe.org>
<%IAYK.567410$YC96.259830@fx12.ams1> <tgv4ah$3a6r$2@dont-email.me>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
<gw5ZK.203513$elEa.38758@fx09.iad> <th2onr$fgth$2@dont-email.me>
<A36ZK.187925$IRd5.90886@fx10.iad> <th2r02$flk6$1@dont-email.me>
<nt6ZK.24903$C8y5.3770@fx07.iad> <th2v0b$flk6$2@dont-email.me>
<Xm7ZK.236360$PRW4.73623@fx11.iad> <th3039$kmq$1@gioia.aioe.org>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th3039$kmq$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 473
Message-ID: <Cw7ZK.221274$9Yp5.21321@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Sep 2022 22:36:17 -0400
X-Received-Bytes: 27773
 by: Richard Damon - Thu, 29 Sep 2022 02:36 UTC

On 9/28/22 10:32 PM, olcott wrote:
> On 9/28/2022 9:25 PM, Richard Damon wrote:
>> On 9/28/22 10:13 PM, olcott wrote:
>>> On 9/28/2022 8:24 PM, Richard Damon wrote:
>>>> On 9/28/22 9:05 PM, olcott wrote:
>>>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will push you out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fair and honest review I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me before I could point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you relied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly be correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is based on a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for P to do the opposite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and their inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contained within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again. H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P isn't recursive and yet
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion is caused by your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nature BECAUSE H IS NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the idea of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (SHD) ever thought all the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at all how the decider got the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM specifies that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description provides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that this input does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM, and thus *ITS*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not define the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in 1 to ∞ steps of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider is to decide on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its words it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to prove that you are technically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, thus this doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ∞ correctly simulated steps, thus predict
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> of 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a
>>>>>>>>>>>>>>>>>>>>>>>>> liar for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation
>>>>>>>>>>>>>>>>>>>>>>>> P(P), or your P isn't the required "impossible
>>>>>>>>>>>>>>>>>>>>>>>> Program".
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees
>>>>>>>>>>>>>>>>>>>>>>> that the actual behavior of the input is not
>>>>>>>>>>>>>>>>>>>>>>> provided by the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most
>>>>>>>>>>>>>>>>>>>>> other are only going by learned-by-rote so when a
>>>>>>>>>>>>>>>>>>>>> new issue comes up your flounder. The others here
>>>>>>>>>>>>>>>>>>>>> not going by learned-by-rote are going by total
>>>>>>>>>>>>>>>>>>>>> cluelessness.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider,
>>>>>>>>>>>>>>>>>>>> the one YOU quote.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an
>>>>>>>>>>>>>>>>>>> input does not provide the actual behavior of this
>>>>>>>>>>>>>>>>>>> input. You will find no competent person that will
>>>>>>>>>>>>>>>>>>> disagree with me on this point.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right
>>>>>>>>>>>>>>>>>> answer is the behavior of the machine that input
>>>>>>>>>>>>>>>>>> describes, so THAT is the behavior that counts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>>>> question of How many cats you have, when you have one
>>>>>>>>>>>>>>>> cats and one dog, because dogs are really pretty much
>>>>>>>>>>>>>>>> like a cat.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that the
>>>>>>>>>>>>>>>>> correct simulation of the input does provide the actual
>>>>>>>>>>>>>>>>> behavior of this input. We know this on the basis of
>>>>>>>>>>>>>>>>> the definition of a UTM.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is like getting off the highway at the second exit,
>>>>>>>>>>>>>>>> well before you get into the city, and announce that
>>>>>>>>>>>>>>>> traffic is clear into the city, because you didn't see
>>>>>>>>>>>>>>>> any traffic.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>>>>>>> computationally equivalent to the direct execution of 1
>>>>>>>>>>>>>>> to ∞ steps of the input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>>>>> single number between 1 and infinity, so you never have a
>>>>>>>>>>>>>> valuation of 1 to infinite steps for any input except
>>>>>>>>>>>>>> those that are basd on an Hx that never stops them, and
>>>>>>>>>>>>>> thos Hx never abort.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>> actual behavior of the input is not provided by the correct
>>>>>>>>>>>>> simulation of this input therefore
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>>>
>>>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>>>
>>>>>>>>>> The ONLY definition of "simulation" for Turing Machines that I
>>>>>>>>>> know of is the UTM, and it only does a complete simulation of
>>>>>>>>>> its input.
>>>>>>>>>>
>>>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>>>> Simulation" as to include a partial one that is applicable here?
>>>>>>>>>
>>>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine
>>>>>>>>> description is necessarily computationally equivalent to a
>>>>>>>>> corresponding 1 to ∞ steps of direct execution.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>>>>> state, yes.
>>>>>>>>
>>>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>>>  > a machine description is necessarily computationally
>>>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>>>  > execution.
>>>>>>>  >
>>>>>>>
>>>>>>> *The problem is that you are a despicable lying bastard*
>>>>>>> Trying to pretend that you didn't see
>>>>>>>
>>>>>>> 1 to ∞ simulated steps
>>>>>>> 1 to ∞ simulated steps
>>>>>>> 1 to ∞ simulated steps
>>>>>>> 1 to ∞ simulated steps
>>>>>>>
>>>>>>
>>>>>> So ARE you claiming that all the Px are the same input, and thus
>>>>>> the behavior of Px doesn't depend on the Hx it calls?
>>>>>>
>>>>> None of the Px elements of the infinite set of Hx/Px pairs reaches
>>>>> its final state and halts when 1 to ∞ steps of Px are simulated (or
>>>>> directly executed) by some Hx.
>>>>>
>>>>> This is enough for anyone with sufficient technical competence that
>>>>> is not a despicable lying bastard to acknowledge that Px is
>>>>> non-halting.
>>>>>
>>>>>
>>>>
>>>> No, it isn't. An infinite number of incomplete answers does not add
>>>> up to a correct answer.
>>>
>>> Because you are a despicable lying bastard you change the subject to
>>> a different point before any point is ever made and validated.
>>
>> No, I didn't/
>>
>>>
>>> The only point being made here is that a correct simulation is not
>>> required to be a complete simulation. If a single step is correctly
>>> simulated then this single step is simulated correctly.
>>>
>>
>> So, the single step being simulated correctly does NOT mean that the
>> input was simulated correct.
>>
> Exactly what a despicable lying bastard would say.
> That one step of an input is simulated correctly DOES MEAN
> That one step of an input is simulated correctly.
>
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th31br$uu6$1@gioia.aioe.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!WLfZA/JXwj9HbHJM5fyP+A.user.46.165.242.91.POSTED!not-for-mail
From: none...@beez-waxes.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 21:53:45 -0500
Organization: Aioe.org NNTP Server
Message-ID: <th31br$uu6$1@gioia.aioe.org>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgtrs5$rgq$1@gioia.aioe.org> <%IAYK.567410$YC96.259830@fx12.ams1>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
<th2n07$fgth$1@dont-email.me> <gw5ZK.203513$elEa.38758@fx09.iad>
<th2onr$fgth$2@dont-email.me> <A36ZK.187925$IRd5.90886@fx10.iad>
<th2r02$flk6$1@dont-email.me> <nt6ZK.24903$C8y5.3770@fx07.iad>
<th2v0b$flk6$2@dont-email.me> <Xm7ZK.236360$PRW4.73623@fx11.iad>
<th3039$kmq$1@gioia.aioe.org> <Cw7ZK.221274$9Yp5.21321@fx12.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="31686"; posting-host="WLfZA/JXwj9HbHJM5fyP+A.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
Content-Language: en-US
X-Notice: Filtered by postfilter v. 0.9.2
 by: olcott - Thu, 29 Sep 2022 02:53 UTC

On 9/28/2022 9:36 PM, Richard Damon wrote:
> On 9/28/22 10:32 PM, olcott wrote:
>> On 9/28/2022 9:25 PM, Richard Damon wrote:
>>> On 9/28/22 10:13 PM, olcott wrote:
>>>> On 9/28/2022 8:24 PM, Richard Damon wrote:
>>>>> On 9/28/22 9:05 PM, olcott wrote:
>>>>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will push you out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a fair and honest review
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me before I could point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you relied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly be correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return value from H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is based on a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for P to do the opposite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P isn't recursive and yet
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the recursion is caused by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nature BECAUSE H IS NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (SHD) ever thought all the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> care at all how the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM specifies that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description provides
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that this input does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be a UTM, and thus *ITS*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not define
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state in 1 to ∞ steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider is to decide on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to report that this input does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its words it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to prove that you are technically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted" but your defiition of H DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, thus this doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ correctly simulated steps, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a
>>>>>>>>>>>>>>>>>>>>>>>>>> liar for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation
>>>>>>>>>>>>>>>>>>>>>>>>> P(P), or your P isn't the required "impossible
>>>>>>>>>>>>>>>>>>>>>>>>> Program".
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees
>>>>>>>>>>>>>>>>>>>>>>>> that the actual behavior of the input is not
>>>>>>>>>>>>>>>>>>>>>>>> provided by the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most
>>>>>>>>>>>>>>>>>>>>>> other are only going by learned-by-rote so when a
>>>>>>>>>>>>>>>>>>>>>> new issue comes up your flounder. The others here
>>>>>>>>>>>>>>>>>>>>>> not going by learned-by-rote are going by total
>>>>>>>>>>>>>>>>>>>>>> cluelessness.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider,
>>>>>>>>>>>>>>>>>>>>> the one YOU quote.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an
>>>>>>>>>>>>>>>>>>>> input does not provide the actual behavior of this
>>>>>>>>>>>>>>>>>>>> input. You will find no competent person that will
>>>>>>>>>>>>>>>>>>>> disagree with me on this point.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right
>>>>>>>>>>>>>>>>>>> answer is the behavior of the machine that input
>>>>>>>>>>>>>>>>>>> describes, so THAT is the behavior that counts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>>>>> question of How many cats you have, when you have one
>>>>>>>>>>>>>>>>> cats and one dog, because dogs are really pretty much
>>>>>>>>>>>>>>>>> like a cat.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that
>>>>>>>>>>>>>>>>>> the correct simulation of the input does provide the
>>>>>>>>>>>>>>>>>> actual behavior of this input. We know this on the
>>>>>>>>>>>>>>>>>> basis of the definition of a UTM.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is like getting off the highway at the second
>>>>>>>>>>>>>>>>> exit, well before you get into the city, and announce
>>>>>>>>>>>>>>>>> that traffic is clear into the city, because you didn't
>>>>>>>>>>>>>>>>> see any traffic.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>>>>>>>>>>>>> computationally equivalent to the direct execution of 1
>>>>>>>>>>>>>>>> to ∞ steps of the input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>>>>>> single number between 1 and infinity, so you never have a
>>>>>>>>>>>>>>> valuation of 1 to infinite steps for any input except
>>>>>>>>>>>>>>> those that are basd on an Hx that never stops them, and
>>>>>>>>>>>>>>> thos Hx never abort.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>> correct simulation of this input therefore
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>>>>
>>>>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>>>>
>>>>>>>>>>> The ONLY definition of "simulation" for Turing Machines that
>>>>>>>>>>> I know of is the UTM, and it only does a complete simulation
>>>>>>>>>>> of its input.
>>>>>>>>>>>
>>>>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>>>>> Simulation" as to include a partial one that is applicable here?
>>>>>>>>>>
>>>>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine
>>>>>>>>>> description is necessarily computationally equivalent to a
>>>>>>>>>> corresponding 1 to ∞ steps of direct execution.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>>>>>> state, yes.
>>>>>>>>>
>>>>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>>>>  > a machine description is necessarily computationally
>>>>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>>>>  > execution.
>>>>>>>>  >
>>>>>>>>
>>>>>>>> *The problem is that you are a despicable lying bastard*
>>>>>>>> Trying to pretend that you didn't see
>>>>>>>>
>>>>>>>> 1 to ∞ simulated steps
>>>>>>>> 1 to ∞ simulated steps
>>>>>>>> 1 to ∞ simulated steps
>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>
>>>>>>>
>>>>>>> So ARE you claiming that all the Px are the same input, and thus
>>>>>>> the behavior of Px doesn't depend on the Hx it calls?
>>>>>>>
>>>>>> None of the Px elements of the infinite set of Hx/Px pairs reaches
>>>>>> its final state and halts when 1 to ∞ steps of Px are simulated
>>>>>> (or directly executed) by some Hx.
>>>>>>
>>>>>> This is enough for anyone with sufficient technical competence
>>>>>> that is not a despicable lying bastard to acknowledge that Px is
>>>>>> non-halting.
>>>>>>
>>>>>>
>>>>>
>>>>> No, it isn't. An infinite number of incomplete answers does not add
>>>>> up to a correct answer.
>>>>
>>>> Because you are a despicable lying bastard you change the subject to
>>>> a different point before any point is ever made and validated.
>>>
>>> No, I didn't/
>>>
>>>>
>>>> The only point being made here is that a correct simulation is not
>>>> required to be a complete simulation. If a single step is correctly
>>>> simulated then this single step is simulated correctly.
>>>>
>>>
>>> So, the single step being simulated correctly does NOT mean that the
>>> input was simulated correct.
>>>
>> Exactly what a despicable lying bastard would say.
>> That one step of an input is simulated correctly DOES MEAN
>> That one step of an input is simulated correctly.
>>
>>
>
> But doesn't mean that the INPUT has been simulated correctly.


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<EU7ZK.511995$Ny99.89894@fx16.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<%IAYK.567410$YC96.259830@fx12.ams1> <tgv4ah$3a6r$2@dont-email.me>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
<gw5ZK.203513$elEa.38758@fx09.iad> <th2onr$fgth$2@dont-email.me>
<A36ZK.187925$IRd5.90886@fx10.iad> <th2r02$flk6$1@dont-email.me>
<nt6ZK.24903$C8y5.3770@fx07.iad> <th2v0b$flk6$2@dont-email.me>
<Xm7ZK.236360$PRW4.73623@fx11.iad> <th3039$kmq$1@gioia.aioe.org>
<Cw7ZK.221274$9Yp5.21321@fx12.iad> <th31br$uu6$1@gioia.aioe.org>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th31br$uu6$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 494
Message-ID: <EU7ZK.511995$Ny99.89894@fx16.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Sep 2022 23:01:56 -0400
X-Received-Bytes: 29478
 by: Richard Damon - Thu, 29 Sep 2022 03:01 UTC

On 9/28/22 10:53 PM, olcott wrote:
> On 9/28/2022 9:36 PM, Richard Damon wrote:
>> On 9/28/22 10:32 PM, olcott wrote:
>>> On 9/28/2022 9:25 PM, Richard Damon wrote:
>>>> On 9/28/22 10:13 PM, olcott wrote:
>>>>> On 9/28/2022 8:24 PM, Richard Damon wrote:
>>>>>> On 9/28/22 9:05 PM, olcott wrote:
>>>>>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>>>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the place to discuss
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> postings will push you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a fair and honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me before I could point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can possibly be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the return value from H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is based on a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible for P to do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs contained within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake again and again.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because P isn't recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and yet you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the recursion is caused by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof does it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nature BECAUSE H IS NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (SHD) ever thought
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> care at all how the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM specifies that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that this input does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be a UTM, and thus *ITS*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not define
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state in 1 to ∞ steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one ever bothered to think the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> application of a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider is to decide on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the meaning
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its words it is irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would seem to prove that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is aborted" but your defiition of H DOES
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation, thus this doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assume that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ correctly simulated steps, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a
>>>>>>>>>>>>>>>>>>>>>>>>>>> liar for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the computation
>>>>>>>>>>>>>>>>>>>>>>>>>> P(P), or your P isn't the required "impossible
>>>>>>>>>>>>>>>>>>>>>>>>>> Program".
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees
>>>>>>>>>>>>>>>>>>>>>>>>> that the actual behavior of the input is not
>>>>>>>>>>>>>>>>>>>>>>>>> provided by the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most
>>>>>>>>>>>>>>>>>>>>>>> other are only going by learned-by-rote so when a
>>>>>>>>>>>>>>>>>>>>>>> new issue comes up your flounder. The others here
>>>>>>>>>>>>>>>>>>>>>>> not going by learned-by-rote are going by total
>>>>>>>>>>>>>>>>>>>>>>> cluelessness.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider,
>>>>>>>>>>>>>>>>>>>>>> the one YOU quote.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an
>>>>>>>>>>>>>>>>>>>>> input does not provide the actual behavior of this
>>>>>>>>>>>>>>>>>>>>> input. You will find no competent person that will
>>>>>>>>>>>>>>>>>>>>> disagree with me on this point.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right
>>>>>>>>>>>>>>>>>>>> answer is the behavior of the machine that input
>>>>>>>>>>>>>>>>>>>> describes, so THAT is the behavior that counts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>>>>>> question of How many cats you have, when you have one
>>>>>>>>>>>>>>>>>> cats and one dog, because dogs are really pretty much
>>>>>>>>>>>>>>>>>> like a cat.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that
>>>>>>>>>>>>>>>>>>> the correct simulation of the input does provide the
>>>>>>>>>>>>>>>>>>> actual behavior of this input. We know this on the
>>>>>>>>>>>>>>>>>>> basis of the definition of a UTM.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is like getting off the highway at the second
>>>>>>>>>>>>>>>>>> exit, well before you get into the city, and announce
>>>>>>>>>>>>>>>>>> that traffic is clear into the city, because you
>>>>>>>>>>>>>>>>>> didn't see any traffic.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input
>>>>>>>>>>>>>>>>> *is* computationally equivalent to the direct execution
>>>>>>>>>>>>>>>>> of 1 to ∞ steps of the input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>>>>>>> single number between 1 and infinity, so you never have
>>>>>>>>>>>>>>>> a valuation of 1 to infinite steps for any input except
>>>>>>>>>>>>>>>> those that are basd on an Hx that never stops them, and
>>>>>>>>>>>>>>>> thos Hx never abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>>> correct simulation of this input therefore
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>>>>>
>>>>>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>>>>>
>>>>>>>>>>>> The ONLY definition of "simulation" for Turing Machines that
>>>>>>>>>>>> I know of is the UTM, and it only does a complete simulation
>>>>>>>>>>>> of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>>>>>> Simulation" as to include a partial one that is applicable
>>>>>>>>>>>> here?
>>>>>>>>>>>
>>>>>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine
>>>>>>>>>>> description is necessarily computationally equivalent to a
>>>>>>>>>>> corresponding 1 to ∞ steps of direct execution.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>>>>>>> state, yes.
>>>>>>>>>>
>>>>>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>>>>>  > a machine description is necessarily computationally
>>>>>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>>>>>  > execution.
>>>>>>>>>  >
>>>>>>>>>
>>>>>>>>> *The problem is that you are a despicable lying bastard*
>>>>>>>>> Trying to pretend that you didn't see
>>>>>>>>>
>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>
>>>>>>>>
>>>>>>>> So ARE you claiming that all the Px are the same input, and thus
>>>>>>>> the behavior of Px doesn't depend on the Hx it calls?
>>>>>>>>
>>>>>>> None of the Px elements of the infinite set of Hx/Px pairs
>>>>>>> reaches its final state and halts when 1 to ∞ steps of Px are
>>>>>>> simulated (or directly executed) by some Hx.
>>>>>>>
>>>>>>> This is enough for anyone with sufficient technical competence
>>>>>>> that is not a despicable lying bastard to acknowledge that Px is
>>>>>>> non-halting.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> No, it isn't. An infinite number of incomplete answers does not
>>>>>> add up to a correct answer.
>>>>>
>>>>> Because you are a despicable lying bastard you change the subject
>>>>> to a different point before any point is ever made and validated.
>>>>
>>>> No, I didn't/
>>>>
>>>>>
>>>>> The only point being made here is that a correct simulation is not
>>>>> required to be a complete simulation. If a single step is correctly
>>>>> simulated then this single step is simulated correctly.
>>>>>
>>>>
>>>> So, the single step being simulated correctly does NOT mean that the
>>>> input was simulated correct.
>>>>
>>> Exactly what a despicable lying bastard would say.
>>> That one step of an input is simulated correctly DOES MEAN
>>> That one step of an input is simulated correctly.
>>>
>>>
>>
>> But doesn't mean that the INPUT has been simulated correctly.
>
> Maybe Electrical Engineers are clueless about tautologies?
>
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<th323o$14mj$1@gioia.aioe.org>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!WLfZA/JXwj9HbHJM5fyP+A.user.46.165.242.91.POSTED!not-for-mail
From: none...@beez-waxes.com (olcott)
Newsgroups: comp.theory
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Date: Wed, 28 Sep 2022 22:06:30 -0500
Organization: Aioe.org NNTP Server
Message-ID: <th323o$14mj$1@gioia.aioe.org>
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<tgv4ah$3a6r$2@dont-email.me> <YhLYK.294354$G_96.174924@fx13.ams1>
<th06ba$67gl$1@dont-email.me> <0fNYK.114886$6gz7.30480@fx37.iad>
<th089p$2hg$1@gioia.aioe.org> <kLNYK.200849$elEa.79945@fx09.iad>
<th09vn$flf$1@gioia.aioe.org> <CfOYK.236274$PRW4.7213@fx11.iad>
<th0bjf$13fc$1@gioia.aioe.org> <1AOYK.231099$51Rb.45426@fx45.iad>
<th0dk0$1jat$1@gioia.aioe.org> <zdWYK.511940$Ny99.268522@fx16.iad>
<th1q44$cu0t$1@dont-email.me> <Wt4ZK.133330$479c.108846@fx48.iad>
<th2lgm$fdtd$1@dont-email.me> <AU4ZK.110024$tRy7.104864@fx36.iad>
<th2n07$fgth$1@dont-email.me> <gw5ZK.203513$elEa.38758@fx09.iad>
<th2onr$fgth$2@dont-email.me> <A36ZK.187925$IRd5.90886@fx10.iad>
<th2r02$flk6$1@dont-email.me> <nt6ZK.24903$C8y5.3770@fx07.iad>
<th2v0b$flk6$2@dont-email.me> <Xm7ZK.236360$PRW4.73623@fx11.iad>
<th3039$kmq$1@gioia.aioe.org> <Cw7ZK.221274$9Yp5.21321@fx12.iad>
<th31br$uu6$1@gioia.aioe.org> <EU7ZK.511995$Ny99.89894@fx16.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="37587"; posting-host="WLfZA/JXwj9HbHJM5fyP+A.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.3.0
Content-Language: en-US
X-Notice: Filtered by postfilter v. 0.9.2
 by: olcott - Thu, 29 Sep 2022 03:06 UTC

On 9/28/2022 10:01 PM, Richard Damon wrote:
> On 9/28/22 10:53 PM, olcott wrote:
>> On 9/28/2022 9:36 PM, Richard Damon wrote:
>>> On 9/28/22 10:32 PM, olcott wrote:
>>>> On 9/28/2022 9:25 PM, Richard Damon wrote:
>>>>> On 9/28/22 10:13 PM, olcott wrote:
>>>>>> On 9/28/2022 8:24 PM, Richard Damon wrote:
>>>>>>> On 9/28/22 9:05 PM, olcott wrote:
>>>>>>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>>>>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>>>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the place to discuss
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> postings will push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me a fair and honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on me before I could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can possibly be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the return value from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is based on a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible for P to do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the opposite of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system (Visual Studio
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same mistake again and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because P isn't recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and yet you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the recursion is caused
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by your H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does it state that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nature BECAUSE H IS NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the idea
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (SHD) ever thought
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> care at all how the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM specifies that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be a UTM, and thus *ITS*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not define
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops running unless aborted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own final state in 1 to ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no one ever bothered to think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the application of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider is to decide on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> earlier ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prevent infinite simulation it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference between the two, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would seem to prove that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (unless their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is aborted" but your defiition of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DOES abort its simulation, thus this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assume that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ∞ correctly simulated steps, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the
>>>>>>>>>>>>>>>>>>>>>>>>>>> computation P(P), or your P isn't the
>>>>>>>>>>>>>>>>>>>>>>>>>>> required "impossible Program".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees
>>>>>>>>>>>>>>>>>>>>>>>>>> that the actual behavior of the input is not
>>>>>>>>>>>>>>>>>>>>>>>>>> provided by the correct simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most
>>>>>>>>>>>>>>>>>>>>>>>> other are only going by learned-by-rote so when
>>>>>>>>>>>>>>>>>>>>>>>> a new issue comes up your flounder. The others
>>>>>>>>>>>>>>>>>>>>>>>> here not going by learned-by-rote are going by
>>>>>>>>>>>>>>>>>>>>>>>> total cluelessness.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt Decider,
>>>>>>>>>>>>>>>>>>>>>>> the one YOU quote.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an
>>>>>>>>>>>>>>>>>>>>>> input does not provide the actual behavior of this
>>>>>>>>>>>>>>>>>>>>>> input. You will find no competent person that will
>>>>>>>>>>>>>>>>>>>>>> disagree with me on this point.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right
>>>>>>>>>>>>>>>>>>>>> answer is the behavior of the machine that input
>>>>>>>>>>>>>>>>>>>>> describes, so THAT is the behavior that counts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>>>>>>> question of How many cats you have, when you have one
>>>>>>>>>>>>>>>>>>> cats and one dog, because dogs are really pretty much
>>>>>>>>>>>>>>>>>>> like a cat.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that
>>>>>>>>>>>>>>>>>>>> the correct simulation of the input does provide the
>>>>>>>>>>>>>>>>>>>> actual behavior of this input. We know this on the
>>>>>>>>>>>>>>>>>>>> basis of the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is like getting off the highway at the second
>>>>>>>>>>>>>>>>>>> exit, well before you get into the city, and announce
>>>>>>>>>>>>>>>>>>> that traffic is clear into the city, because you
>>>>>>>>>>>>>>>>>>> didn't see any traffic.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input
>>>>>>>>>>>>>>>>>> *is* computationally equivalent to the direct
>>>>>>>>>>>>>>>>>> execution of 1 to ∞ steps of the input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You only "correctly simulate" a given input once, for a
>>>>>>>>>>>>>>>>> single number between 1 and infinity, so you never have
>>>>>>>>>>>>>>>>> a valuation of 1 to infinite steps for any input except
>>>>>>>>>>>>>>>>> those that are basd on an Hx that never stops them, and
>>>>>>>>>>>>>>>>> thos Hx never abort.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>>>> correct simulation of this input therefore
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The ONLY definition of "simulation" for Turing Machines
>>>>>>>>>>>>> that I know of is the UTM, and it only does a complete
>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>>>>>>> Simulation" as to include a partial one that is applicable
>>>>>>>>>>>>> here?
>>>>>>>>>>>>
>>>>>>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine
>>>>>>>>>>>> description is necessarily computationally equivalent to a
>>>>>>>>>>>> corresponding 1 to ∞ steps of direct execution.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Infinite steps, or more steps than it takes to reach the
>>>>>>>>>>> final state, yes.
>>>>>>>>>>>
>>>>>>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>>>>>>  > a machine description is necessarily computationally
>>>>>>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>>>>>>  > execution.
>>>>>>>>>>  >
>>>>>>>>>>
>>>>>>>>>> *The problem is that you are a despicable lying bastard*
>>>>>>>>>> Trying to pretend that you didn't see
>>>>>>>>>>
>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So ARE you claiming that all the Px are the same input, and
>>>>>>>>> thus the behavior of Px doesn't depend on the Hx it calls?
>>>>>>>>>
>>>>>>>> None of the Px elements of the infinite set of Hx/Px pairs
>>>>>>>> reaches its final state and halts when 1 to ∞ steps of Px are
>>>>>>>> simulated (or directly executed) by some Hx.
>>>>>>>>
>>>>>>>> This is enough for anyone with sufficient technical competence
>>>>>>>> that is not a despicable lying bastard to acknowledge that Px is
>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> No, it isn't. An infinite number of incomplete answers does not
>>>>>>> add up to a correct answer.
>>>>>>
>>>>>> Because you are a despicable lying bastard you change the subject
>>>>>> to a different point before any point is ever made and validated.
>>>>>
>>>>> No, I didn't/
>>>>>
>>>>>>
>>>>>> The only point being made here is that a correct simulation is not
>>>>>> required to be a complete simulation. If a single step is
>>>>>> correctly simulated then this single step is simulated correctly.
>>>>>>
>>>>>
>>>>> So, the single step being simulated correctly does NOT mean that
>>>>> the input was simulated correct.
>>>>>
>>>> Exactly what a despicable lying bastard would say.
>>>> That one step of an input is simulated correctly DOES MEAN
>>>> That one step of an input is simulated correctly.
>>>>
>>>>
>>>
>>> But doesn't mean that the INPUT has been simulated correctly.
>>
>> Maybe Electrical Engineers are clueless about tautologies?
>>
>>
>
> Not the problem. But it appears that Olcotts are too stupid to
> understand simple logic.
>


Click here to read the complete article
Re: The Halting Problem proofs have a fatal flaw [ Visual Studio c/c++ project ]

<m38ZK.343782$wLZ8.3440@fx18.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.1
Subject: Re: The Halting Problem proofs have a fatal flaw [ Visual Studio
c/c++ project ]
Content-Language: en-US
Newsgroups: comp.theory
References: <09b41edc-a57b-4521-ba66-8517b55f2e69n@googlegroups.com>
<YhLYK.294354$G_96.174924@fx13.ams1> <th06ba$67gl$1@dont-email.me>
<0fNYK.114886$6gz7.30480@fx37.iad> <th089p$2hg$1@gioia.aioe.org>
<kLNYK.200849$elEa.79945@fx09.iad> <th09vn$flf$1@gioia.aioe.org>
<CfOYK.236274$PRW4.7213@fx11.iad> <th0bjf$13fc$1@gioia.aioe.org>
<1AOYK.231099$51Rb.45426@fx45.iad> <th0dk0$1jat$1@gioia.aioe.org>
<zdWYK.511940$Ny99.268522@fx16.iad> <th1q44$cu0t$1@dont-email.me>
<Wt4ZK.133330$479c.108846@fx48.iad> <th2lgm$fdtd$1@dont-email.me>
<AU4ZK.110024$tRy7.104864@fx36.iad> <th2n07$fgth$1@dont-email.me>
<gw5ZK.203513$elEa.38758@fx09.iad> <th2onr$fgth$2@dont-email.me>
<A36ZK.187925$IRd5.90886@fx10.iad> <th2r02$flk6$1@dont-email.me>
<nt6ZK.24903$C8y5.3770@fx07.iad> <th2v0b$flk6$2@dont-email.me>
<Xm7ZK.236360$PRW4.73623@fx11.iad> <th3039$kmq$1@gioia.aioe.org>
<Cw7ZK.221274$9Yp5.21321@fx12.iad> <th31br$uu6$1@gioia.aioe.org>
<EU7ZK.511995$Ny99.89894@fx16.iad> <th323o$14mj$1@gioia.aioe.org>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <th323o$14mj$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 539
Message-ID: <m38ZK.343782$wLZ8.3440@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 28 Sep 2022 23:13:21 -0400
X-Received-Bytes: 32179
 by: Richard Damon - Thu, 29 Sep 2022 03:13 UTC

On 9/28/22 11:06 PM, olcott wrote:
> On 9/28/2022 10:01 PM, Richard Damon wrote:
>> On 9/28/22 10:53 PM, olcott wrote:
>>> On 9/28/2022 9:36 PM, Richard Damon wrote:
>>>> On 9/28/22 10:32 PM, olcott wrote:
>>>>> On 9/28/2022 9:25 PM, Richard Damon wrote:
>>>>>> On 9/28/22 10:13 PM, olcott wrote:
>>>>>>> On 9/28/2022 8:24 PM, Richard Damon wrote:
>>>>>>>> On 9/28/22 9:05 PM, olcott wrote:
>>>>>>>>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>>>>>>>>> On 9/28/22 8:26 PM, olcott wrote:
>>>>>>>>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>>>>>>>>> On 9/28/2022 6:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/28/22 7:31 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/28/2022 6:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/28/22 11:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <none-ya@beez-waxes.com>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.lang.c is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the place to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> postings will push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me a fair and honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on me before I could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> relied on for your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argument merely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that no value
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can possibly be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the return value from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is based on a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible for P to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do the opposite of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs contained
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same mistake again and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because P isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive and yet you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the recursion is caused
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by your H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does it state that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nature BECAUSE H IS NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (besides mine) is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> idea of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (SHD) ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thought all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> care at all how the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM specifies that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> underlying machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whenever any simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN'T be a UTM, and thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *ITS* simulation does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> define the "behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops running unless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted conclusively proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in 1 to ∞ steps of correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is asking for is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no one ever bothered to think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the application of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider is to decide on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obsolete by a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> makes earlier ideas about this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description provides the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to report that this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the basis of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> material difference between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> two, that would seem to prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a non-halting input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      //
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicate unique finite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strings
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then these steps would keep
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating: (unless their simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is aborted)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is aborted" but your defiition of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DOES abort its simulation, thus this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't occur.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we replace H with a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assume that it is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is designed to predict the result of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1 to ∞ correctly simulated steps, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> predict the behavior of a UTM simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H does correctly predict the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of 1 to ∞ simulated steps of P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> returns 0, then P(P) will Halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That is false and you know it so you are a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar for the 500th time*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You know that you are not referring to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of an input to H*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation P(P), or your P isn't the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> required "impossible Program".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You cannot find a competent source that
>>>>>>>>>>>>>>>>>>>>>>>>>>> agrees that the actual behavior of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>> is not provided by the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So like I said you have no source, you and most
>>>>>>>>>>>>>>>>>>>>>>>>> other are only going by learned-by-rote so when
>>>>>>>>>>>>>>>>>>>>>>>>> a new issue comes up your flounder. The others
>>>>>>>>>>>>>>>>>>>>>>>>> here not going by learned-by-rote are going by
>>>>>>>>>>>>>>>>>>>>>>>>> total cluelessness.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> What about the Linz definition of a Halt
>>>>>>>>>>>>>>>>>>>>>>>> Decider, the one YOU quote.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> He does not say that the correct simulation of an
>>>>>>>>>>>>>>>>>>>>>>> input does not provide the actual behavior of
>>>>>>>>>>>>>>>>>>>>>>> this input. You will find no competent person
>>>>>>>>>>>>>>>>>>>>>>> that will disagree with me on this point.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But he DOES say that the DEFINITION of the right
>>>>>>>>>>>>>>>>>>>>>> answer is the behavior of the machine that input
>>>>>>>>>>>>>>>>>>>>>> describes, so THAT is the behavior that counts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> People that know these things more deeply than
>>>>>>>>>>>>>>>>>>>>> learned-by-rote will understand that my alternative
>>>>>>>>>>>>>>>>>>>>> definition is sound.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is like saying Two is the right answer to the
>>>>>>>>>>>>>>>>>>>> question of How many cats you have, when you have
>>>>>>>>>>>>>>>>>>>> one cats and one dog, because dogs are really pretty
>>>>>>>>>>>>>>>>>>>> much like a cat.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We can know that it is sound by simply knowing that
>>>>>>>>>>>>>>>>>>>>> the correct simulation of the input does provide
>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input. We know this on
>>>>>>>>>>>>>>>>>>>>> the basis of the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The CORRECT AND COMPLETE.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is like getting off the highway at the second
>>>>>>>>>>>>>>>>>>>> exit, well before you get into the city, and
>>>>>>>>>>>>>>>>>>>> announce that traffic is clear into the city,
>>>>>>>>>>>>>>>>>>>> because you didn't see any traffic.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are just PROVING our stupidity.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Mike already corrected you on this.
>>>>>>>>>>>>>>>>>>> The correct simulation of 1 to ∞ steps of the input
>>>>>>>>>>>>>>>>>>> *is* computationally equivalent to the direct
>>>>>>>>>>>>>>>>>>> execution of 1 to ∞ steps of the input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> How can you disagree with this besides lying?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You only "correctly simulate" a given input once, for
>>>>>>>>>>>>>>>>>> a single number between 1 and infinity, so you never
>>>>>>>>>>>>>>>>>> have a valuation of 1 to infinite steps for any input
>>>>>>>>>>>>>>>>>> except those that are basd on an Hx that never stops
>>>>>>>>>>>>>>>>>> them, and thos Hx never abort.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>>>>>> actual behavior of the input is not provided by the
>>>>>>>>>>>>>>>>> correct simulation of this input therefore
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that the problem is that "Correct Simulation" is
>>>>>>>>>>>>>>>> generally taken to be a Correct and Complete Simulation,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *No it is not and Mike already corrected you on this*
>>>>>>>>>>>>>>> You stubbornly insistent on lying.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The ONLY definition of "simulation" for Turing Machines
>>>>>>>>>>>>>> that I know of is the UTM, and it only does a complete
>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Care to provide a reliable source that defines a "Correct
>>>>>>>>>>>>>> Simulation" as to include a partial one that is applicable
>>>>>>>>>>>>>> here?
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you weren't a despicable lying bastard you would already
>>>>>>>>>>>>> acknowledge that 1 to ∞ simulated steps of a machine
>>>>>>>>>>>>> description is necessarily computationally equivalent to a
>>>>>>>>>>>>> corresponding 1 to ∞ steps of direct execution.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Infinite steps, or more steps than it takes to reach the
>>>>>>>>>>>> final state, yes.
>>>>>>>>>>>>
>>>>>>>>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>>>>>>>>  > *If you weren't a despicable lying bastard* you would
>>>>>>>>>>>  > already acknowledge that 1 to ∞ simulated steps of
>>>>>>>>>>>  > a machine description is necessarily computationally
>>>>>>>>>>>  > equivalent to a corresponding 1 to ∞ steps of direct
>>>>>>>>>>>  > execution.
>>>>>>>>>>>  >
>>>>>>>>>>>
>>>>>>>>>>> *The problem is that you are a despicable lying bastard*
>>>>>>>>>>> Trying to pretend that you didn't see
>>>>>>>>>>>
>>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>>> 1 to ∞ simulated steps
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So ARE you claiming that all the Px are the same input, and
>>>>>>>>>> thus the behavior of Px doesn't depend on the Hx it calls?
>>>>>>>>>>
>>>>>>>>> None of the Px elements of the infinite set of Hx/Px pairs
>>>>>>>>> reaches its final state and halts when 1 to ∞ steps of Px are
>>>>>>>>> simulated (or directly executed) by some Hx.
>>>>>>>>>
>>>>>>>>> This is enough for anyone with sufficient technical competence
>>>>>>>>> that is not a despicable lying bastard to acknowledge that Px
>>>>>>>>> is non-halting.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, it isn't. An infinite number of incomplete answers does not
>>>>>>>> add up to a correct answer.
>>>>>>>
>>>>>>> Because you are a despicable lying bastard you change the subject
>>>>>>> to a different point before any point is ever made and validated.
>>>>>>
>>>>>> No, I didn't/
>>>>>>
>>>>>>>
>>>>>>> The only point being made here is that a correct simulation is
>>>>>>> not required to be a complete simulation. If a single step is
>>>>>>> correctly simulated then this single step is simulated correctly.
>>>>>>>
>>>>>>
>>>>>> So, the single step being simulated correctly does NOT mean that
>>>>>> the input was simulated correct.
>>>>>>
>>>>> Exactly what a despicable lying bastard would say.
>>>>> That one step of an input is simulated correctly DOES MEAN
>>>>> That one step of an input is simulated correctly.
>>>>>
>>>>>
>>>>
>>>> But doesn't mean that the INPUT has been simulated correctly.
>>>
>>> Maybe Electrical Engineers are clueless about tautologies?
>>>
>>>
>>
>> Not the problem. But it appears that Olcotts are too stupid to
>> understand simple logic.
>>
>
> That you won't even agree to tautologies means that you are on the wrong
> side of righteousness. You are on the side of the adversary.
>


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

rocksolid light 0.9.8
clearnet tor