Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

My little brother got this fortune: nohup rm -fr /& So he did...


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

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

Pages:123456789101112
Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<st4e5g$1rbi$1@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: gettabr...@gmail.net (Greta Baine)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Date: Sat, 29 Jan 2022 14:13:05 -0800
Organization: Aioe.org NNTP Server
Message-ID: <st4e5g$1rbi$1@gioia.aioe.org>
References: <ssh8vu$4c0$1@dont-email.me> <ssue1i$81l$1@dont-email.me>
<AfGIJ.3844$dV.1984@fx44.iad> <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st3vrv$hnh$1@dont-email.me> <st4208$bg4$3@gioia.aioe.org>
<YYWdnTmmToZ1DWj8nZ2dnUU7-amdnZ2d@giganews.com>
Reply-To: gettabrane@gmail.net
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="60786"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Greta Baine - Sat, 29 Jan 2022 22:13 UTC

On 1/29/2022 11:09 AM, olcott wrote:
> On 1/29/2022 12:45 PM, Greta Baine wrote:
>> On 1/29/2022 10:09 AM, olcott wrote:
>>
>> (nothing)
>>
>> Get a brain you impotent blithering twatwaffle,
>
> This is merely another way of saying the you know that you are totally
> incompetent to point out even a single error in anything that I have said.
>

Your posts are entirely free of meaningful content; they resemble and
explosion at an ASCII factory - random characters thrown onto a screen.
No comment on your posts is necessary except for this advice:
Shut up idiot.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<st62tu$f6h$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Date: Sun, 30 Jan 2022 07:13:31 -0600
Organization: A noiseless patient Spider
Lines: 76
Message-ID: <st62tu$f6h$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me> <ssue1i$81l$1@dont-email.me>
<AfGIJ.3844$dV.1984@fx44.iad> <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 30 Jan 2022 13:13:34 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="31d4c6db7c1c2ddf7d2f32eb3c2fecac";
logging-data="15569"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18en3FC+qtKKmkL1o5JjURV"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:fbeFg6J0nUr0STb5W3sUERtwNiw=
In-Reply-To: <875yq2h2ea.fsf@bsb.me.uk>
Content-Language: en-US
 by: olcott - Sun, 30 Jan 2022 13:13 UTC

On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>> the computation the input actually does when run as an independent
>> machine, or what a UTM will do when simulating that input.
>>
>> If that isn't the meaning you are using, then you are just lying that
>> you are working on the halting problem, which is what seems to be the
>> case. (That you are lying that is).
>
> It is certainly true that PO is not addressing the halting problem. He
> has been 100% clear that false is, in his "opinion", the correct result
> for at least one halting computation. This is not in dispute (unless
> he's retracted that and I missed it).
>
> To you and I, this means that he's not working on the halting problem,
> but I am not sure you can say he is lying about that. For one thing,
> how can he be intending to deceive (a core part of lying) when he's been
> clear the he accepts the wrong answer as being the right one? If
> someone claims to be working on "the addition problem", and also claims
> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
> The person is just deeply confused.
>
> But what sort of confused can explain this nonsense? I think the answer
> lies in PO's background. The "binary square root" function is not
> computable as far as a mathematician is concerned because no TM can halt
> with, say, sqrt(0b10) on the tape. But to an engineer, the function
> poses no problem because we can get as close as we like. If
> 0b1.01101010000 is not good enough, just add more digits.
>
> The point is I think PO does not know what a formal, mathematical
> problem really is. To him, anything about code, machines or programs is
> about solving an engineering problem "well enough" -- with "well enough"
> open to be defined by PO himself.
>
> More disturbing to me is that he is not even talking about Turing
> machines, again as evidenced by his own plain words. It is not in
> dispute that he claims that two (deterministic) TMs, one an identical
> copy of the other, can transition to different states despite both being
> presented with identical input. These are not Turing machines but Magic
> machines, and I can't see how any discussion can be had while the action
> of the things being considered is not a simple function of the input and
> the state transition graph.
>

Although Turing machines might not be able to tell that two computations
differ on their basis of their machine address x86 machines can do this.

When an x86 computation bases its halt status decision on the same
function being called with the same input and the measure of the same
function is its machine address then two copies of an x86 computation
that are otherwise exactly the same do differ by their machine address.

Since computation is conditioned on this machine address then it is
obvious that two functions that are identical except for their machine
address can have different output on the same input.

If we do a string comparison of the machine code bytes as out measure of
identical functions then two identical functions will derive the same
output from the same input.

Since H and embedded_H are not identical functions when they are
compared on the basis of their finite strings equality does not match.

> This is why I stopped replying. While there are things to say about
> PO's Other Halting problem (principally that even the POOH problem can't
> be solved), I had nothing more to say while the "machines" being
> discussed are magic.
>

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<LCwJJ.50318$gX.12924@fx40.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx40.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <ssue1i$81l$1@dont-email.me>
<AfGIJ.3844$dV.1984@fx44.iad> <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <st62tu$f6h$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 118
Message-ID: <LCwJJ.50318$gX.12924@fx40.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 08:44:12 -0500
X-Received-Bytes: 7278
 by: Richard Damon - Sun, 30 Jan 2022 13:44 UTC

On 1/30/22 8:13 AM, olcott wrote:
> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>> the computation the input actually does when run as an independent
>>> machine, or what a UTM will do when simulating that input.
>>>
>>> If that isn't the meaning you are using, then you are just lying that
>>> you are working on the halting problem, which is what seems to be the
>>> case. (That you are lying that is).
>>
>> It is certainly true that PO is not addressing the halting problem.  He
>> has been 100% clear that false is, in his "opinion", the correct result
>> for at least one halting computation.  This is not in dispute (unless
>> he's retracted that and I missed it).
>>
>> To you and I, this means that he's not working on the halting problem,
>> but I am not sure you can say he is lying about that.  For one thing,
>> how can he be intending to deceive (a core part of lying) when he's been
>> clear the he accepts the wrong answer as being the right one?  If
>> someone claims to be working on "the addition problem", and also claims
>> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
>> The person is just deeply confused.
>>
>> But what sort of confused can explain this nonsense?  I think the answer
>> lies in PO's background.  The "binary square root" function is not
>> computable as far as a mathematician is concerned because no TM can halt
>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>> poses no problem because we can get as close as we like.  If
>> 0b1.01101010000 is not good enough, just add more digits.
>>
>> The point is I think PO does not know what a formal, mathematical
>> problem really is.  To him, anything about code, machines or programs is
>> about solving an engineering problem "well enough" -- with "well enough"
>> open to be defined by PO himself.
>>
>> More disturbing to me is that he is not even talking about Turing
>> machines, again as evidenced by his own plain words.  It is not in
>> dispute that he claims that two (deterministic) TMs, one an identical
>> copy of the other, can transition to different states despite both being
>> presented with identical input.  These are not Turing machines but Magic
>> machines, and I can't see how any discussion can be had while the action
>> of the things being considered is not a simple function of the input and
>> the state transition graph.
>>
>
> Although Turing machines might not be able to tell that two computations
> differ on their basis of their machine address x86 machines can do this.

But the proof is on Turing Machines, and not all x86 'programs' are the
equivalent to Turing Machines, only those that meet the requirements of
being a Computation.

This seems to be the core of your problem, you don't understand what a
computation actually is, and want to use the WRONG definition of it
being anything a modern computer does. Wrong defintions, wrong results.

>
> When an x86 computation bases its halt status decision on the same
> function being called with the same input and the measure of the same
> function is its machine address then two copies of an x86 computation
> that are otherwise exactly the same do differ by their machine address.

Again, if the x86 program IS a computation, then it will be the
equivalent of a Turing Machine, and won't be able to do anything more
than the Turing Machine could (but maybe in less steps).

Your 'Halt Decider' seems to fail the tests to be actually a
computation. at least of its defined parameters.

>
> Since computation is conditioned on this machine address then it is
> obvious that two functions that are identical except for their machine
> address can have different output on the same input.

And a function that is dependent on the machine address it is loaded at,
when looked at as a computation, has an extra 'input' to it, its machine
address it is loaded at. This is your problem.

By definition, a correct halt decider must have exactly two inputs, the
representation of the machine it is to decide on, and the input to that
machine. If your H has another input, then it is not even the right form
for a halt decider.

>
> If we do a string comparison of the machine code bytes as out measure of
> identical functions then two identical functions will derive the same
> output from the same input.

Remember, the machine code bytes of P include all the bytes of H, BY
DEFINITION, if P is going to be anything close to what H^ is defined in
the Halting Problem as shown by Linz.

>
> Since H and embedded_H are not identical functions when they are
> compared on the basis of their finite strings equality does not match.
>

And that is exactly the proof that you are not following the
requirements of the Halting Problem and Linz.

H^ needs to be built on EXACTLY H, with changes OUTSIDE the operation of H.

So, you seemed to have just admitted that your work is NOT applicable to
the Halting Problem of Computation Theory.

FAIL.

>
>> This is why I stopped replying.  While there are things to say about
>> PO's Other Halting problem (principally that even the POOH problem can't
>> be solved), I had nothing more to say while the "machines" being
>> discussed are magic.
>>
>
>

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 09:32:27 -0600
Date: Sun, 30 Jan 2022 09:32:26 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <ssue1i$81l$1@dont-email.me>
<AfGIJ.3844$dV.1984@fx44.iad> <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <LCwJJ.50318$gX.12924@fx40.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com>
Lines: 108
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Z78/x3nXMocqJXGOWt06yTkPvDApB8G8FPFYCH0Fb2jNPT0lG8kROvWKpORA1mF1JkzJt86cpukO4N9!bxOKyxQmO1HoPQK4avvqm5ilOQ1JvlKGVL/iZ6xPzWXkasMQRy6r9GaIOU4+SdqRAefC3nJsMKjI
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7439
 by: olcott - Sun, 30 Jan 2022 15:32 UTC

On 1/30/2022 7:44 AM, Richard Damon wrote:
> On 1/30/22 8:13 AM, olcott wrote:
>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>>> the computation the input actually does when run as an independent
>>>> machine, or what a UTM will do when simulating that input.
>>>>
>>>> If that isn't the meaning you are using, then you are just lying that
>>>> you are working on the halting problem, which is what seems to be the
>>>> case. (That you are lying that is).
>>>
>>> It is certainly true that PO is not addressing the halting problem.  He
>>> has been 100% clear that false is, in his "opinion", the correct result
>>> for at least one halting computation.  This is not in dispute (unless
>>> he's retracted that and I missed it).
>>>
>>> To you and I, this means that he's not working on the halting problem,
>>> but I am not sure you can say he is lying about that.  For one thing,
>>> how can he be intending to deceive (a core part of lying) when he's been
>>> clear the he accepts the wrong answer as being the right one?  If
>>> someone claims to be working on "the addition problem", and also claims
>>> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
>>> The person is just deeply confused.
>>>
>>> But what sort of confused can explain this nonsense?  I think the answer
>>> lies in PO's background.  The "binary square root" function is not
>>> computable as far as a mathematician is concerned because no TM can halt
>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>>> poses no problem because we can get as close as we like.  If
>>> 0b1.01101010000 is not good enough, just add more digits.
>>>
>>> The point is I think PO does not know what a formal, mathematical
>>> problem really is.  To him, anything about code, machines or programs is
>>> about solving an engineering problem "well enough" -- with "well enough"
>>> open to be defined by PO himself.
>>>
>>> More disturbing to me is that he is not even talking about Turing
>>> machines, again as evidenced by his own plain words.  It is not in
>>> dispute that he claims that two (deterministic) TMs, one an identical
>>> copy of the other, can transition to different states despite both being
>>> presented with identical input.  These are not Turing machines but Magic
>>> machines, and I can't see how any discussion can be had while the action
>>> of the things being considered is not a simple function of the input and
>>> the state transition graph.
>>>
>>
>> Although Turing machines might not be able to tell that two
>> computations differ on their basis of their machine address x86
>> machines can do this.
>
> But the proof is on Turing Machines, and not all x86 'programs' are the
> equivalent to Turing Machines, only those that meet the requirements of
> being a Computation.
>
> This seems to be the core of your problem, you don't understand what a
> computation actually is, and want to use the WRONG definition of it
> being anything a modern computer does. Wrong defintions, wrong results.
>

When a halt decider bases its halt status decision on the behavior of
the correct simulation of a finite number of N steps of its input there
is nothing about this that is not a computation.

When this simulating halt decider correctly determines that its
simulated input cannot possibly reach its final state in any finite
number of steps this too is computable.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When the copy of H embedded at Ĥ.qx correctly recognizes this repeating
pattern:

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

This too is a computation.

When embedded_H correctly recognizes the above repeating pattern then
this gives embedded_H the basis to know that its simulated input will
never reach its final state thus fails to meet this Linz definition of
halting: computation that halts … the Turing machine will halt whenever
it enters a final state. (Linz:1990:234).

The source of the errors of everyone else on this is failing to realize
that:

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correctly
simulated input can possibly reach its final state in any finite number
of steps.

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<_bzJJ.7760$rU.4222@fx34.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx34.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <ssue1i$81l$1@dont-email.me>
<AfGIJ.3844$dV.1984@fx44.iad> <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 162
Message-ID: <_bzJJ.7760$rU.4222@fx34.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 11:40:28 -0500
X-Received-Bytes: 9125
 by: Richard Damon - Sun, 30 Jan 2022 16:40 UTC

On 1/30/22 10:32 AM, olcott wrote:
> On 1/30/2022 7:44 AM, Richard Damon wrote:
>> On 1/30/22 8:13 AM, olcott wrote:
>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>>>> the computation the input actually does when run as an independent
>>>>> machine, or what a UTM will do when simulating that input.
>>>>>
>>>>> If that isn't the meaning you are using, then you are just lying that
>>>>> you are working on the halting problem, which is what seems to be the
>>>>> case. (That you are lying that is).
>>>>
>>>> It is certainly true that PO is not addressing the halting problem.  He
>>>> has been 100% clear that false is, in his "opinion", the correct result
>>>> for at least one halting computation.  This is not in dispute (unless
>>>> he's retracted that and I missed it).
>>>>
>>>> To you and I, this means that he's not working on the halting problem,
>>>> but I am not sure you can say he is lying about that.  For one thing,
>>>> how can he be intending to deceive (a core part of lying) when he's
>>>> been
>>>> clear the he accepts the wrong answer as being the right one?  If
>>>> someone claims to be working on "the addition problem", and also claims
>>>> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
>>>> The person is just deeply confused.
>>>>
>>>> But what sort of confused can explain this nonsense?  I think the
>>>> answer
>>>> lies in PO's background.  The "binary square root" function is not
>>>> computable as far as a mathematician is concerned because no TM can
>>>> halt
>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>>>> poses no problem because we can get as close as we like.  If
>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>
>>>> The point is I think PO does not know what a formal, mathematical
>>>> problem really is.  To him, anything about code, machines or
>>>> programs is
>>>> about solving an engineering problem "well enough" -- with "well
>>>> enough"
>>>> open to be defined by PO himself.
>>>>
>>>> More disturbing to me is that he is not even talking about Turing
>>>> machines, again as evidenced by his own plain words.  It is not in
>>>> dispute that he claims that two (deterministic) TMs, one an identical
>>>> copy of the other, can transition to different states despite both
>>>> being
>>>> presented with identical input.  These are not Turing machines but
>>>> Magic
>>>> machines, and I can't see how any discussion can be had while the
>>>> action
>>>> of the things being considered is not a simple function of the input
>>>> and
>>>> the state transition graph.
>>>>
>>>
>>> Although Turing machines might not be able to tell that two
>>> computations differ on their basis of their machine address x86
>>> machines can do this.
>>
>> But the proof is on Turing Machines, and not all x86 'programs' are
>> the equivalent to Turing Machines, only those that meet the
>> requirements of being a Computation.
>>
>> This seems to be the core of your problem, you don't understand what a
>> computation actually is, and want to use the WRONG definition of it
>> being anything a modern computer does. Wrong defintions, wrong results.
>>
>
> When a halt decider bases its halt status decision on the behavior of
> the correct simulation of a finite number of N steps of its input there
> is nothing about this that is not a computation.

Except that that is the WRONG definition of Halting. You can NOT
accurate determine halting with only FIXED number N of steps.

Remember, Halting means it reaches that state in ANY 'N', not just a
given N.
>
> When this simulating halt decider correctly determines that its
> simulated input cannot possibly reach its final state in any finite
> number of steps this too is computable.

Except it isn't correct by the right definition.

Also, it has been proven that there exists no finite pattern that H can
use to prove it in a finite number of steps.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When the copy of H embedded at Ĥ.qx correctly recognizes this repeating
> pattern:
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

But ONLY if H never aborts. Yes, if THAT is your H, it is correct that
H^ <H^> is non-halting, but such an H will never give an answer.

Change H to abort to give the answer, and the pattern no longer appears,
or you are lying that you built H^ correctly.

Remember, the copy of embedded_H must be identical (between H.q0 and
H.qy/H.qn) to what is in H, and thus with the same input will behave
identiaally, the if H goes to H.qn, so will embedded_H, and thus the H^
that this embedded_H is in will go to H^.Qn and Halt, thus the input to
H/embedded_H is shown to Halt.

>
> This too is a computation.

Yes, you can build a computation to get the WRONG results that you
quote, but either your embedded_H isn't a copy of H or it is using a
pattern that doesn't actually occur as an infinite pattern.

FALIL.

>
> When embedded_H correctly recognizes the above repeating pattern then
> this gives embedded_H the basis to know that its simulated input will
> never reach its final state thus fails to meet this Linz definition of
> halting: computation that halts … the Turing machine will halt whenever
> it enters a final state. (Linz:1990:234).
>
> The source of the errors of everyone else on this is failing to realize
> that:
>
> Because all simulating halt deciders are deciders they are only
> accountable for computing the mapping from their input finite strings to
> an accept or reject state on the basis of whether or not their correctly
> simulated input can possibly reach its final state in any finite number
> of steps.
>

But the behavior of H^ applied to <H^> IS the results that H is
accoutable unless you are lying about working on the Halting Problem.

The fact that the mapping based on that fact is not computable, doesn't
give H the 'right' to change what it needs to give to be correct, it
just means that it will be incorrect for some input.

As has been shown, if H <H^> <H^> -> H.Qn in a finite number of steps,
then H^ <H^> will also go to H^.Qn in a finite (but larger) number of
steps and Halt, and thus UTM <H^> <H^> is Halting, and thus the correct
answer to the Halting Problem for this input is HALTING, not non-halting.

FAIL.

> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 11:05:11 -0600
Date: Sun, 30 Jan 2022 11:05:10 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <ssue1i$81l$1@dont-email.me>
<AfGIJ.3844$dV.1984@fx44.iad> <sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <_bzJJ.7760$rU.4222@fx34.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
Lines: 116
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Hwpsx6Yi8dygfjBGmby6b9otIJ+OdxcW63BD5KrsL7YL56oPF9XdIFwn3n5CblSdvyHFhoBRLCs6RI8!oI8iJ6tE+ONwWjE5YmkQgYKnN5QYvMlv5xff15Q84vjaTL04HAEMMU3lZGbuQ7IrZR4DUHnA9TB2
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7428
 by: olcott - Sun, 30 Jan 2022 17:05 UTC

On 1/30/2022 10:40 AM, Richard Damon wrote:
> On 1/30/22 10:32 AM, olcott wrote:
>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>> On 1/30/22 8:13 AM, olcott wrote:
>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>>>>> the computation the input actually does when run as an independent
>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>
>>>>>> If that isn't the meaning you are using, then you are just lying that
>>>>>> you are working on the halting problem, which is what seems to be the
>>>>>> case. (That you are lying that is).
>>>>>
>>>>> It is certainly true that PO is not addressing the halting
>>>>> problem.  He
>>>>> has been 100% clear that false is, in his "opinion", the correct
>>>>> result
>>>>> for at least one halting computation.  This is not in dispute (unless
>>>>> he's retracted that and I missed it).
>>>>>
>>>>> To you and I, this means that he's not working on the halting problem,
>>>>> but I am not sure you can say he is lying about that.  For one thing,
>>>>> how can he be intending to deceive (a core part of lying) when he's
>>>>> been
>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>> someone claims to be working on "the addition problem", and also
>>>>> claims
>>>>> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
>>>>> The person is just deeply confused.
>>>>>
>>>>> But what sort of confused can explain this nonsense?  I think the
>>>>> answer
>>>>> lies in PO's background.  The "binary square root" function is not
>>>>> computable as far as a mathematician is concerned because no TM can
>>>>> halt
>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>>>>> poses no problem because we can get as close as we like.  If
>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>
>>>>> The point is I think PO does not know what a formal, mathematical
>>>>> problem really is.  To him, anything about code, machines or
>>>>> programs is
>>>>> about solving an engineering problem "well enough" -- with "well
>>>>> enough"
>>>>> open to be defined by PO himself.
>>>>>
>>>>> More disturbing to me is that he is not even talking about Turing
>>>>> machines, again as evidenced by his own plain words.  It is not in
>>>>> dispute that he claims that two (deterministic) TMs, one an identical
>>>>> copy of the other, can transition to different states despite both
>>>>> being
>>>>> presented with identical input.  These are not Turing machines but
>>>>> Magic
>>>>> machines, and I can't see how any discussion can be had while the
>>>>> action
>>>>> of the things being considered is not a simple function of the
>>>>> input and
>>>>> the state transition graph.
>>>>>
>>>>
>>>> Although Turing machines might not be able to tell that two
>>>> computations differ on their basis of their machine address x86
>>>> machines can do this.
>>>
>>> But the proof is on Turing Machines, and not all x86 'programs' are
>>> the equivalent to Turing Machines, only those that meet the
>>> requirements of being a Computation.
>>>
>>> This seems to be the core of your problem, you don't understand what
>>> a computation actually is, and want to use the WRONG definition of it
>>> being anything a modern computer does. Wrong defintions, wrong results.
>>>
>>
>> When a halt decider bases its halt status decision on the behavior of
>> the correct simulation of a finite number of N steps of its input
>> there is nothing about this that is not a computation.
>
> Except that that is the WRONG definition of Halting. You can NOT
> accurate determine halting with only FIXED number N of steps.
>

This is a stupid mistake on your part.

It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by
embedded_H shows an infinitely repeating pattern in less than four
simulation cycles.

That you deny things that are dead obvious is what I call your mistakes
stupid mistakes rather than simply mistakes.

>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When the copy of H embedded at Ĥ.qx correctly recognizes this
>> repeating pattern:
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>> ⟨Ĥ5⟩...

>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<st6hnh$1rll$1@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: snord...@snootdink.com (Snorkeldink Curdlesnoot)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Date: Sun, 30 Jan 2022 09:26:08 -0800
Organization: Aioe.org NNTP Server
Message-ID: <st6hnh$1rll$1@gioia.aioe.org>
References: <ssh8vu$4c0$1@dont-email.me> <AfGIJ.3844$dV.1984@fx44.iad>
<sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
Reply-To: snordurd@snootdink.com
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="61109"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Content-Language: en-US
X-Notice: Filtered by postfilter v. 0.9.2
 by: Snorkeldink Curdlesn - Sun, 30 Jan 2022 17:26 UTC

On 1/30/2022 9:05 AM, olcott wrote:
>

Get a brain soon you ass.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<d5AJJ.57716$4C3.3626@fx13.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <AfGIJ.3844$dV.1984@fx44.iad>
<sOSdnaE1LMP1qG78nZ2dnUU7-L3NnZ2d@giganews.com>
<UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 175
Message-ID: <d5AJJ.57716$4C3.3626@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 12:41:31 -0500
X-Received-Bytes: 9450
X-Original-Bytes: 9317
 by: Richard Damon - Sun, 30 Jan 2022 17:41 UTC

On 1/30/22 12:05 PM, olcott wrote:
> On 1/30/2022 10:40 AM, Richard Damon wrote:
>> On 1/30/22 10:32 AM, olcott wrote:
>>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>>> On 1/30/22 8:13 AM, olcott wrote:
>>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>>>>>> the computation the input actually does when run as an independent
>>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>>
>>>>>>> If that isn't the meaning you are using, then you are just lying
>>>>>>> that
>>>>>>> you are working on the halting problem, which is what seems to be
>>>>>>> the
>>>>>>> case. (That you are lying that is).
>>>>>>
>>>>>> It is certainly true that PO is not addressing the halting
>>>>>> problem.  He
>>>>>> has been 100% clear that false is, in his "opinion", the correct
>>>>>> result
>>>>>> for at least one halting computation.  This is not in dispute (unless
>>>>>> he's retracted that and I missed it).
>>>>>>
>>>>>> To you and I, this means that he's not working on the halting
>>>>>> problem,
>>>>>> but I am not sure you can say he is lying about that.  For one thing,
>>>>>> how can he be intending to deceive (a core part of lying) when
>>>>>> he's been
>>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>>> someone claims to be working on "the addition problem", and also
>>>>>> claims
>>>>>> that 2+2=5 is correct, it's hard to consider either claim to be a
>>>>>> lie.
>>>>>> The person is just deeply confused.
>>>>>>
>>>>>> But what sort of confused can explain this nonsense?  I think the
>>>>>> answer
>>>>>> lies in PO's background.  The "binary square root" function is not
>>>>>> computable as far as a mathematician is concerned because no TM
>>>>>> can halt
>>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>>>>>> poses no problem because we can get as close as we like.  If
>>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>>
>>>>>> The point is I think PO does not know what a formal, mathematical
>>>>>> problem really is.  To him, anything about code, machines or
>>>>>> programs is
>>>>>> about solving an engineering problem "well enough" -- with "well
>>>>>> enough"
>>>>>> open to be defined by PO himself.
>>>>>>
>>>>>> More disturbing to me is that he is not even talking about Turing
>>>>>> machines, again as evidenced by his own plain words.  It is not in
>>>>>> dispute that he claims that two (deterministic) TMs, one an identical
>>>>>> copy of the other, can transition to different states despite both
>>>>>> being
>>>>>> presented with identical input.  These are not Turing machines but
>>>>>> Magic
>>>>>> machines, and I can't see how any discussion can be had while the
>>>>>> action
>>>>>> of the things being considered is not a simple function of the
>>>>>> input and
>>>>>> the state transition graph.
>>>>>>
>>>>>
>>>>> Although Turing machines might not be able to tell that two
>>>>> computations differ on their basis of their machine address x86
>>>>> machines can do this.
>>>>
>>>> But the proof is on Turing Machines, and not all x86 'programs' are
>>>> the equivalent to Turing Machines, only those that meet the
>>>> requirements of being a Computation.
>>>>
>>>> This seems to be the core of your problem, you don't understand what
>>>> a computation actually is, and want to use the WRONG definition of
>>>> it being anything a modern computer does. Wrong defintions, wrong
>>>> results.
>>>>
>>>
>>> When a halt decider bases its halt status decision on the behavior of
>>> the correct simulation of a finite number of N steps of its input
>>> there is nothing about this that is not a computation.
>>
>> Except that that is the WRONG definition of Halting. You can NOT
>> accurate determine halting with only FIXED number N of steps.
>>
>
> This is a stupid mistake on your part.
>
> It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by
> embedded_H shows an infinitely repeating pattern in less than four
> simulation cycles.
>
> That you deny things that are dead obvious is what I call your mistakes
> stupid mistakes rather than simply mistakes.

You need to use the right definition, based on the Halting Problem.

The fact that you need to change it just proves that your haven't got a
prayer with the right definitions.

NOTHING in the actual definition mentions anything about the behavior of
the decider in determining if the computation actually halts.

In fact, if you knew the first thing of Computation Theory, you would
know that such a definition that includes that would actually be
IMPOSSIBLE, as Halting is a Property of the Computation itself, and
needs to be the same no matter what decider tries to decide on it.

The fact that you rely on things that seem 'dead obvious' to you shows
that you just don't understand how actual logic and proofs work. You
don't start with things that are 'obvious', you start with the things
DEFINED to be true, and the things that have been proven to be true
based on those definition.

Using the 'obvious' is one of the biggest sources of fallacies.

We can show that your 'claim' is not true, at least for a H that aborts
its simulation and goes to H.Qn, so you claim is shown to be a flat out lie.

Yes, if H NEVER aborts its simulation, you can use your logic to show
that H^ <H^> is non-halting, but then you need to lie that somehow, H,
without aborting its simulation does get to H.Qn to report that fact,
Yes, in that case it would have been correct to do so, but a simulating
halt decider that both simulates its input forever and also transitions
to H.Qn to indicate non-halting is just a Fairy Dust powered Unicorn
that doesn't exist.

If H DOES abort, so that it can get to H.Qn, the the simple trace of the
actual pure simulation of the input is:

H^.Q0 <H^>
which get to (in finite time):
H^.Qx <H^> <H^> which starts the copy of H.Q0 <H^> <H^>
Which by the property of computations, since we have a stipulation that
the computation H <H^> <H^> -> H.Qn we know that H^ will go to its
mapped state H^.Qn, So we get to

H^.Qn, which Halts.

Thus, we have actually PROVED (and not just claimed) that if we have
that H <H^> <H^> -> H.Qn then H^ <H^> -> H^.Qn and Halts.

Thus, your 'claim' is shown to be false, AGAIN.
Repeating false claims is just a form of Lying.

Clearly your 'obvious' is obviously WRONG.

Admit it and cleanse your soul.

>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When the copy of H embedded at Ĥ.qx correctly recognizes this
>>> repeating pattern:
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>> ⟨Ĥ5⟩...
>
>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>
>


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

<gVBJJ.317834$qz4.289863@fx97.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx97.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <UHGIJ.15876$mS1.15729@fx10.iad>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 181
Message-ID: <gVBJJ.317834$qz4.289863@fx97.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 14:45:18 -0500
X-Received-Bytes: 9686
 by: Richard Damon - Sun, 30 Jan 2022 19:45 UTC

On 1/30/22 2:18 PM, olcott wrote:
> On 1/30/2022 11:41 AM, Richard Damon wrote:
>> On 1/30/22 12:05 PM, olcott wrote:
>>> On 1/30/2022 10:40 AM, Richard Damon wrote:
>>>> On 1/30/22 10:32 AM, olcott wrote:
>>>>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>>>>> On 1/30/22 8:13 AM, olcott wrote:
>>>>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>
>>>>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to be
>>>>>>>>> what
>>>>>>>>> the computation the input actually does when run as an independent
>>>>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>>>>
>>>>>>>>> If that isn't the meaning you are using, then you are just
>>>>>>>>> lying that
>>>>>>>>> you are working on the halting problem, which is what seems to
>>>>>>>>> be the
>>>>>>>>> case. (That you are lying that is).
>>>>>>>>
>>>>>>>> It is certainly true that PO is not addressing the halting
>>>>>>>> problem.  He
>>>>>>>> has been 100% clear that false is, in his "opinion", the correct
>>>>>>>> result
>>>>>>>> for at least one halting computation.  This is not in dispute
>>>>>>>> (unless
>>>>>>>> he's retracted that and I missed it).
>>>>>>>>
>>>>>>>> To you and I, this means that he's not working on the halting
>>>>>>>> problem,
>>>>>>>> but I am not sure you can say he is lying about that.  For one
>>>>>>>> thing,
>>>>>>>> how can he be intending to deceive (a core part of lying) when
>>>>>>>> he's been
>>>>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>>>>> someone claims to be working on "the addition problem", and also
>>>>>>>> claims
>>>>>>>> that 2+2=5 is correct, it's hard to consider either claim to be
>>>>>>>> a lie.
>>>>>>>> The person is just deeply confused.
>>>>>>>>
>>>>>>>> But what sort of confused can explain this nonsense?  I think
>>>>>>>> the answer
>>>>>>>> lies in PO's background.  The "binary square root" function is not
>>>>>>>> computable as far as a mathematician is concerned because no TM
>>>>>>>> can halt
>>>>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the
>>>>>>>> function
>>>>>>>> poses no problem because we can get as close as we like.  If
>>>>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>>>>
>>>>>>>> The point is I think PO does not know what a formal, mathematical
>>>>>>>> problem really is.  To him, anything about code, machines or
>>>>>>>> programs is
>>>>>>>> about solving an engineering problem "well enough" -- with "well
>>>>>>>> enough"
>>>>>>>> open to be defined by PO himself.
>>>>>>>>
>>>>>>>> More disturbing to me is that he is not even talking about Turing
>>>>>>>> machines, again as evidenced by his own plain words.  It is not in
>>>>>>>> dispute that he claims that two (deterministic) TMs, one an
>>>>>>>> identical
>>>>>>>> copy of the other, can transition to different states despite
>>>>>>>> both being
>>>>>>>> presented with identical input.  These are not Turing machines
>>>>>>>> but Magic
>>>>>>>> machines, and I can't see how any discussion can be had while
>>>>>>>> the action
>>>>>>>> of the things being considered is not a simple function of the
>>>>>>>> input and
>>>>>>>> the state transition graph.
>>>>>>>>
>>>>>>>
>>>>>>> Although Turing machines might not be able to tell that two
>>>>>>> computations differ on their basis of their machine address x86
>>>>>>> machines can do this.
>>>>>>
>>>>>> But the proof is on Turing Machines, and not all x86 'programs'
>>>>>> are the equivalent to Turing Machines, only those that meet the
>>>>>> requirements of being a Computation.
>>>>>>
>>>>>> This seems to be the core of your problem, you don't understand
>>>>>> what a computation actually is, and want to use the WRONG
>>>>>> definition of it being anything a modern computer does. Wrong
>>>>>> defintions, wrong results.
>>>>>>
>>>>>
>>>>> When a halt decider bases its halt status decision on the behavior
>>>>> of the correct simulation of a finite number of N steps of its
>>>>> input there is nothing about this that is not a computation.
>>>>
>>>> Except that that is the WRONG definition of Halting. You can NOT
>>>> accurate determine halting with only FIXED number N of steps.
>>>>
>>>
>>> This is a stupid mistake on your part.
>>>
>>> It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> by embedded_H shows an infinitely repeating pattern in less than four
>>> simulation cycles.
>>>
>>> That you deny things that are dead obvious is what I call your
>>> mistakes stupid mistakes rather than simply mistakes.
>>
>> You need to use the right definition, based on the Halting Problem.
>>
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)

Right, NOT "When a halt decider bases its halt status decision on the
behavior of the correct simulation of a finite number of N steps of its
input there is nothing about this that is not a computation."

We need to look at the ACTUAL TURING MACHINE, even if you want to call
that comming in the 'back door;

>
>> The fact that you need to change it just proves that your haven't got
>> a prayer with the right definitions.
>>
>> NOTHING in the actual definition mentions anything about the behavior
>> of the decider in determining if the computation actually halts.
>>
>> In fact, if you knew the first thing of Computation Theory, you would
>> know that such a definition that includes that would actually be
>> IMPOSSIBLE, as Halting is a Property of the Computation itself, and
>> needs to be the same no matter what decider tries to decide on it.
>>
>> The fact that you rely on things that seem 'dead obvious' to you shows
>> that you just don't understand how actual logic and proofs work. You
>> don't start with things that are 'obvious', you start with the things
>> DEFINED to be true, and the things that have been proven to be true
>> based on those definition.
>>
>> Using the 'obvious' is one of the biggest sources of fallacies.
>>
>>
>> We can show that your 'claim' is not true, at least for a H that
>> aborts its simulation and goes to H.Qn,
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> So in other words you believe that when embedded_H aborts the simulation
> of its input that this aborted input transitions to ⟨Ĥ⟩.qn even though
> it has been aborted?
>

You mincing your words again.

The DEFINITION of the operation that determines the 'Halting Behavior of
the Input', is the ACTUAL RUNNING OF THE MACHINE REPRESENTED BY THE INPUT.

That machine does not halt just because H/embedded_H aborts its
simulation of its input.


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

<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 14:09:23 -0600
Date: Sun, 30 Jan 2022 14:09:17 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me>
<Q-qdnbZG2LyroG78nZ2dnUU7-LfNnZ2d@giganews.com>
<_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <gVBJJ.317834$qz4.289863@fx97.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
Lines: 191
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vLqVUpfayTLbXXXxUQOBs+9YsvvTfPpKgLAqYY/bzMsj2o/lG5zoEcwEl4uivSqKw0ahWoaW6iAvqBT!3cTVT81iLcalYXLzKGhTX1pAAyA3AGDwbjOolrHuPW/MpFJWdfQ52COU3riLWjSYnXy1GCiJgX/b
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 10908
 by: olcott - Sun, 30 Jan 2022 20:09 UTC

On 1/30/2022 1:45 PM, Richard Damon wrote:
> On 1/30/22 2:18 PM, olcott wrote:
>> On 1/30/2022 11:41 AM, Richard Damon wrote:
>>> On 1/30/22 12:05 PM, olcott wrote:
>>>> On 1/30/2022 10:40 AM, Richard Damon wrote:
>>>>> On 1/30/22 10:32 AM, olcott wrote:
>>>>>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>>>>>> On 1/30/22 8:13 AM, olcott wrote:
>>>>>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to
>>>>>>>>>> be what
>>>>>>>>>> the computation the input actually does when run as an
>>>>>>>>>> independent
>>>>>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>>>>>
>>>>>>>>>> If that isn't the meaning you are using, then you are just
>>>>>>>>>> lying that
>>>>>>>>>> you are working on the halting problem, which is what seems to
>>>>>>>>>> be the
>>>>>>>>>> case. (That you are lying that is).
>>>>>>>>>
>>>>>>>>> It is certainly true that PO is not addressing the halting
>>>>>>>>> problem.  He
>>>>>>>>> has been 100% clear that false is, in his "opinion", the
>>>>>>>>> correct result
>>>>>>>>> for at least one halting computation.  This is not in dispute
>>>>>>>>> (unless
>>>>>>>>> he's retracted that and I missed it).
>>>>>>>>>
>>>>>>>>> To you and I, this means that he's not working on the halting
>>>>>>>>> problem,
>>>>>>>>> but I am not sure you can say he is lying about that.  For one
>>>>>>>>> thing,
>>>>>>>>> how can he be intending to deceive (a core part of lying) when
>>>>>>>>> he's been
>>>>>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>>>>>> someone claims to be working on "the addition problem", and
>>>>>>>>> also claims
>>>>>>>>> that 2+2=5 is correct, it's hard to consider either claim to be
>>>>>>>>> a lie.
>>>>>>>>> The person is just deeply confused.
>>>>>>>>>
>>>>>>>>> But what sort of confused can explain this nonsense?  I think
>>>>>>>>> the answer
>>>>>>>>> lies in PO's background.  The "binary square root" function is not
>>>>>>>>> computable as far as a mathematician is concerned because no TM
>>>>>>>>> can halt
>>>>>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the
>>>>>>>>> function
>>>>>>>>> poses no problem because we can get as close as we like.  If
>>>>>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>>>>>
>>>>>>>>> The point is I think PO does not know what a formal, mathematical
>>>>>>>>> problem really is.  To him, anything about code, machines or
>>>>>>>>> programs is
>>>>>>>>> about solving an engineering problem "well enough" -- with
>>>>>>>>> "well enough"
>>>>>>>>> open to be defined by PO himself.
>>>>>>>>>
>>>>>>>>> More disturbing to me is that he is not even talking about Turing
>>>>>>>>> machines, again as evidenced by his own plain words.  It is not in
>>>>>>>>> dispute that he claims that two (deterministic) TMs, one an
>>>>>>>>> identical
>>>>>>>>> copy of the other, can transition to different states despite
>>>>>>>>> both being
>>>>>>>>> presented with identical input.  These are not Turing machines
>>>>>>>>> but Magic
>>>>>>>>> machines, and I can't see how any discussion can be had while
>>>>>>>>> the action
>>>>>>>>> of the things being considered is not a simple function of the
>>>>>>>>> input and
>>>>>>>>> the state transition graph.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Although Turing machines might not be able to tell that two
>>>>>>>> computations differ on their basis of their machine address x86
>>>>>>>> machines can do this.
>>>>>>>
>>>>>>> But the proof is on Turing Machines, and not all x86 'programs'
>>>>>>> are the equivalent to Turing Machines, only those that meet the
>>>>>>> requirements of being a Computation.
>>>>>>>
>>>>>>> This seems to be the core of your problem, you don't understand
>>>>>>> what a computation actually is, and want to use the WRONG
>>>>>>> definition of it being anything a modern computer does. Wrong
>>>>>>> defintions, wrong results.
>>>>>>>
>>>>>>
>>>>>> When a halt decider bases its halt status decision on the behavior
>>>>>> of the correct simulation of a finite number of N steps of its
>>>>>> input there is nothing about this that is not a computation.
>>>>>
>>>>> Except that that is the WRONG definition of Halting. You can NOT
>>>>> accurate determine halting with only FIXED number N of steps.
>>>>>
>>>>
>>>> This is a stupid mistake on your part.
>>>>
>>>> It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> by embedded_H shows an infinitely repeating pattern in less than
>>>> four simulation cycles.
>>>>
>>>> That you deny things that are dead obvious is what I call your
>>>> mistakes stupid mistakes rather than simply mistakes.
>>>
>>> You need to use the right definition, based on the Halting Problem.
>>>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
> Right, NOT "When a halt decider bases its halt status decision on the
> behavior of the correct simulation of a finite number of N steps of its
> input there is nothing about this that is not a computation."
>
> We need to look at the ACTUAL TURING MACHINE, even if you want to call
> that comming in the 'back door;

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correct
simulation of this input can possibly reach the final state of this
simulated input in any finite number of steps.

>>
>>> The fact that you need to change it just proves that your haven't got
>>> a prayer with the right definitions.
>>>
>>> NOTHING in the actual definition mentions anything about the behavior
>>> of the decider in determining if the computation actually halts.
>>>
>>> In fact, if you knew the first thing of Computation Theory, you would
>>> know that such a definition that includes that would actually be
>>> IMPOSSIBLE, as Halting is a Property of the Computation itself, and
>>> needs to be the same no matter what decider tries to decide on it.
>>>
>>> The fact that you rely on things that seem 'dead obvious' to you
>>> shows that you just don't understand how actual logic and proofs
>>> work. You don't start with things that are 'obvious', you start with
>>> the things DEFINED to be true, and the things that have been proven
>>> to be true based on those definition.
>>>
>>> Using the 'obvious' is one of the biggest sources of fallacies.
>>>
>>>
>>> We can show that your 'claim' is not true, at least for a H that
>>> aborts its simulation and goes to H.Qn,
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> So in other words you believe that when embedded_H aborts the
>> simulation of its input that this aborted input transitions to ⟨Ĥ⟩.qn
>> even though it has been aborted?
>>
>
> You mincing your words again.
>
> The DEFINITION of the operation that determines the 'Halting Behavior of
> the Input', is the ACTUAL RUNNING OF THE MACHINE REPRESENTED BY THE INPUT.
>
> That machine does not halt just because H/embedded_H aborts its
> simulation of its input.
>
> So, YES, when embedded_H aborts ITS PARTIAL simulation of its input,
> that the ACTUAL MACHINE it represents will continue on to H^.Qn.
Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correct
simulation of this input can possibly reach the final state of this
simulated input in any finite number of steps.


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

<mWCJJ.57596$zV.23696@fx43.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <_2IIJ.42013$i%.2716@fx04.iad>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 222
Message-ID: <mWCJJ.57596$zV.23696@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 15:54:44 -0500
X-Received-Bytes: 11989
X-Original-Bytes: 11855
 by: Richard Damon - Sun, 30 Jan 2022 20:54 UTC

On 1/30/22 3:09 PM, olcott wrote:
> On 1/30/2022 1:45 PM, Richard Damon wrote:
>> On 1/30/22 2:18 PM, olcott wrote:
>>> On 1/30/2022 11:41 AM, Richard Damon wrote:
>>>> On 1/30/22 12:05 PM, olcott wrote:
>>>>> On 1/30/2022 10:40 AM, Richard Damon wrote:
>>>>>> On 1/30/22 10:32 AM, olcott wrote:
>>>>>>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>>>>>>> On 1/30/22 8:13 AM, olcott wrote:
>>>>>>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>
>>>>>>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to
>>>>>>>>>>> be what
>>>>>>>>>>> the computation the input actually does when run as an
>>>>>>>>>>> independent
>>>>>>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>>>>>>
>>>>>>>>>>> If that isn't the meaning you are using, then you are just
>>>>>>>>>>> lying that
>>>>>>>>>>> you are working on the halting problem, which is what seems
>>>>>>>>>>> to be the
>>>>>>>>>>> case. (That you are lying that is).
>>>>>>>>>>
>>>>>>>>>> It is certainly true that PO is not addressing the halting
>>>>>>>>>> problem.  He
>>>>>>>>>> has been 100% clear that false is, in his "opinion", the
>>>>>>>>>> correct result
>>>>>>>>>> for at least one halting computation.  This is not in dispute
>>>>>>>>>> (unless
>>>>>>>>>> he's retracted that and I missed it).
>>>>>>>>>>
>>>>>>>>>> To you and I, this means that he's not working on the halting
>>>>>>>>>> problem,
>>>>>>>>>> but I am not sure you can say he is lying about that.  For one
>>>>>>>>>> thing,
>>>>>>>>>> how can he be intending to deceive (a core part of lying) when
>>>>>>>>>> he's been
>>>>>>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>>>>>>> someone claims to be working on "the addition problem", and
>>>>>>>>>> also claims
>>>>>>>>>> that 2+2=5 is correct, it's hard to consider either claim to
>>>>>>>>>> be a lie.
>>>>>>>>>> The person is just deeply confused.
>>>>>>>>>>
>>>>>>>>>> But what sort of confused can explain this nonsense?  I think
>>>>>>>>>> the answer
>>>>>>>>>> lies in PO's background.  The "binary square root" function is
>>>>>>>>>> not
>>>>>>>>>> computable as far as a mathematician is concerned because no
>>>>>>>>>> TM can halt
>>>>>>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the
>>>>>>>>>> function
>>>>>>>>>> poses no problem because we can get as close as we like.  If
>>>>>>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>>>>>>
>>>>>>>>>> The point is I think PO does not know what a formal, mathematical
>>>>>>>>>> problem really is.  To him, anything about code, machines or
>>>>>>>>>> programs is
>>>>>>>>>> about solving an engineering problem "well enough" -- with
>>>>>>>>>> "well enough"
>>>>>>>>>> open to be defined by PO himself.
>>>>>>>>>>
>>>>>>>>>> More disturbing to me is that he is not even talking about Turing
>>>>>>>>>> machines, again as evidenced by his own plain words.  It is
>>>>>>>>>> not in
>>>>>>>>>> dispute that he claims that two (deterministic) TMs, one an
>>>>>>>>>> identical
>>>>>>>>>> copy of the other, can transition to different states despite
>>>>>>>>>> both being
>>>>>>>>>> presented with identical input.  These are not Turing machines
>>>>>>>>>> but Magic
>>>>>>>>>> machines, and I can't see how any discussion can be had while
>>>>>>>>>> the action
>>>>>>>>>> of the things being considered is not a simple function of the
>>>>>>>>>> input and
>>>>>>>>>> the state transition graph.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Although Turing machines might not be able to tell that two
>>>>>>>>> computations differ on their basis of their machine address x86
>>>>>>>>> machines can do this.
>>>>>>>>
>>>>>>>> But the proof is on Turing Machines, and not all x86 'programs'
>>>>>>>> are the equivalent to Turing Machines, only those that meet the
>>>>>>>> requirements of being a Computation.
>>>>>>>>
>>>>>>>> This seems to be the core of your problem, you don't understand
>>>>>>>> what a computation actually is, and want to use the WRONG
>>>>>>>> definition of it being anything a modern computer does. Wrong
>>>>>>>> defintions, wrong results.
>>>>>>>>
>>>>>>>
>>>>>>> When a halt decider bases its halt status decision on the
>>>>>>> behavior of the correct simulation of a finite number of N steps
>>>>>>> of its input there is nothing about this that is not a computation.
>>>>>>
>>>>>> Except that that is the WRONG definition of Halting. You can NOT
>>>>>> accurate determine halting with only FIXED number N of steps.
>>>>>>
>>>>>
>>>>> This is a stupid mistake on your part.
>>>>>
>>>>> It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to
>>>>> ⟨Ĥ⟩ by embedded_H shows an infinitely repeating pattern in less
>>>>> than four simulation cycles.
>>>>>
>>>>> That you deny things that are dead obvious is what I call your
>>>>> mistakes stupid mistakes rather than simply mistakes.
>>>>
>>>> You need to use the right definition, based on the Halting Problem.
>>>>
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>
>> Right, NOT "When a halt decider bases its halt status decision on the
>> behavior of the correct simulation of a finite number of N steps of
>> its input there is nothing about this that is not a computation."
>>
>> We need to look at the ACTUAL TURING MACHINE, even if you want to call
>> that comming in the 'back door;
>
> Because all simulating halt deciders are deciders they are only
> accountable for computing the mapping from their input finite strings to
> an accept or reject state on the basis of whether or not their correct
> simulation of this input can possibly reach the final state of this
> simulated input in any finite number of steps.
>

WRONG. If the mapping isn't the ACTUAL HALTING FUNCION, which is based
on the actual behavior of the machine which the input represents, then
it isn't a HALT DECIDER.

Guess you just admitted that you aren't working on the halting problem,
because you are insisting on a DIFFERENT critera.

FAIL.

>>>
>>>> The fact that you need to change it just proves that your haven't
>>>> got a prayer with the right definitions.
>>>>
>>>> NOTHING in the actual definition mentions anything about the
>>>> behavior of the decider in determining if the computation actually
>>>> halts.
>>>>
>>>> In fact, if you knew the first thing of Computation Theory, you
>>>> would know that such a definition that includes that would actually
>>>> be IMPOSSIBLE, as Halting is a Property of the Computation itself,
>>>> and needs to be the same no matter what decider tries to decide on it.
>>>>
>>>> The fact that you rely on things that seem 'dead obvious' to you
>>>> shows that you just don't understand how actual logic and proofs
>>>> work. You don't start with things that are 'obvious', you start with
>>>> the things DEFINED to be true, and the things that have been proven
>>>> to be true based on those definition.
>>>>
>>>> Using the 'obvious' is one of the biggest sources of fallacies.
>>>>
>>>>
>>>> We can show that your 'claim' is not true, at least for a H that
>>>> aborts its simulation and goes to H.Qn,
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> So in other words you believe that when embedded_H aborts the
>>> simulation of its input that this aborted input transitions to ⟨Ĥ⟩.qn
>>> even though it has been aborted?
>>>
>>
>> You mincing your words again.
>>
>> The DEFINITION of the operation that determines the 'Halting Behavior
>> of the Input', is the ACTUAL RUNNING OF THE MACHINE REPRESENTED BY THE
>> INPUT.
>>
>> That machine does not halt just because H/embedded_H aborts its
>> simulation of its input.
>>
>> So, YES, when embedded_H aborts ITS PARTIAL simulation of its input,
>> that the ACTUAL MACHINE it represents will continue on to H^.Qn.
> Because all simulating halt deciders are deciders they are only
> accountable for computing the mapping from their input finite strings to
> an accept or reject state on the basis of whether or not their correct
> simulation of this input can possibly reach the final state of this
> simulated input in any finite number of steps.
>
> It is like you put a guard on the front door that is supposed to report
> anyone coming in the front door (the actual inputs). Then someone comes
> in the back door (non inputs) and the guard does not report this. Since
> the guard is only supposed to report people coming in the front door it
> is incorrect to say that the guard made a mistake by not reporting
> people that came in the back door.
>
> embedded_H is not supposed to report on the halt status of the
> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>
>


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

<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 15:21:09 -0600
Date: Sun, 30 Jan 2022 15:21:08 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<j7qdnfXC79Kv0m78nZ2dnUU7-UWdnZ2d@giganews.com> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <mWCJJ.57596$zV.23696@fx43.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
Lines: 62
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4smNf50rEm0etW6U/GS/cNJ2taiU6nH4AyUTBWYX7YqemFPQK7VgBfAV7AJdy3z9Np73jsLqGYOej/J!n9MgDp8uCwfmh/Vwo3aF/+fO0t83bj/5Q0OxN4sWPInrioiifNJQn20UBer2A7oIRUNgmtQlQXrz
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4942
 by: olcott - Sun, 30 Jan 2022 21:21 UTC

On 1/30/2022 2:54 PM, Richard Damon wrote:
> On 1/30/22 3:09 PM, olcott wrote:

>> Because all simulating halt deciders are deciders they are only
>> accountable for computing the mapping from their input finite strings
>> to an accept or reject state on the basis of whether or not their
>> correct simulation of this input can possibly reach the final state of
>> this simulated input in any finite number of steps.
>>
>> It is like you put a guard on the front door that is supposed to
>> report anyone coming in the front door (the actual inputs). Then
>> someone comes in the back door (non inputs) and the guard does not
>> report this. Since the guard is only supposed to report people coming
>> in the front door it is incorrect to say that the guard made a mistake
>> by not reporting people that came in the back door.
>>
>> embedded_H is not supposed to report on the halt status of the
>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>
>>
>
> So, you have just admitted that you aren't working on the Halting
> Problem, so any claims therein are just lies.
>
> Since the definition of the Halting Problem refers to the ACTUAL
> behavior of the machine the input represents, and NOT the partial
> simulation that some simulating halt decider might do, you are admitting
> that you H is NOT using the Halting Problem definition and thus your
> claims that your results apply to the Halting problem are just lies.
>
> For the Halting Problem, the correct results for the inputs is based on
> the actual behavior of the machine, or its equivalent the simulation of
> the input with a REAL UTM. Thus the 'Front Door' to the problem s based
> on that, so either you your guards are lying or, what seems more likely,
> you posted them to the wrong door.
>
> You have basically just proved that you have totally wasted the last
> years of your life, as you have been working on the wrong problem,
> because you just don't understand what the problem you wanted to solve
> actually was.
>
> FAIL.

Sum(int X, int Y) { return X + Y );

It is true that halt deciders must report on the actual behavior of
their actual inputs in the same way that Sum(2,5) must return 7.

It is true that the halt status of the actual behavior of the actual
input is correctly determined on the basis of whether or not the correct
simulation of the inputs by a simulating halt decider can possibly reach
a final state of this simulated input.

These things are known to be true on the basis of the meaning of their
words.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<osEJJ.11004$uP.10312@fx16.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <dsIIJ.28249$XU.692@fx38.iad>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 87
Message-ID: <osEJJ.11004$uP.10312@fx16.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 17:39:16 -0500
X-Received-Bytes: 5605
 by: Richard Damon - Sun, 30 Jan 2022 22:39 UTC

On 1/30/22 4:21 PM, olcott wrote:
> On 1/30/2022 2:54 PM, Richard Damon wrote:
>> On 1/30/22 3:09 PM, olcott wrote:
>
>>> Because all simulating halt deciders are deciders they are only
>>> accountable for computing the mapping from their input finite strings
>>> to an accept or reject state on the basis of whether or not their
>>> correct simulation of this input can possibly reach the final state
>>> of this simulated input in any finite number of steps.
>>>
>>> It is like you put a guard on the front door that is supposed to
>>> report anyone coming in the front door (the actual inputs). Then
>>> someone comes in the back door (non inputs) and the guard does not
>>> report this. Since the guard is only supposed to report people coming
>>> in the front door it is incorrect to say that the guard made a
>>> mistake by not reporting people that came in the back door.
>>>
>>> embedded_H is not supposed to report on the halt status of the
>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>
>>>
>>
>> So, you have just admitted that you aren't working on the Halting
>> Problem, so any claims therein are just lies.
>>
>> Since the definition of the Halting Problem refers to the ACTUAL
>> behavior of the machine the input represents, and NOT the partial
>> simulation that some simulating halt decider might do, you are
>> admitting that you H is NOT using the Halting Problem definition and
>> thus your claims that your results apply to the Halting problem are
>> just lies.
>>
>> For the Halting Problem, the correct results for the inputs is based
>> on the actual behavior of the machine, or its equivalent the
>> simulation of the input with a REAL UTM. Thus the 'Front Door' to the
>> problem s based on that, so either you your guards are lying or, what
>> seems more likely, you posted them to the wrong door.
>>
>> You have basically just proved that you have totally wasted the last
>> years of your life, as you have been working on the wrong problem,
>> because you just don't understand what the problem you wanted to solve
>> actually was.
>>
>> FAIL.
>
> Sum(int X, int Y) { return X + Y );
>
> It is true that halt deciders must report on the actual behavior of
> their actual inputs in the same way that Sum(2,5) must return 7.

Right, and the correct answer for if H(wM, w) should report halting is
if M x will reach a final state in a finite number of steps. This is
identical to if UTM(wM, w) will halt. Dosn't matter what you think
otherwise, that IS the definition of the actual behavior.

It is NOT something based on the partial simulation that H does.

PERIOD.

FAIL.

It is proven that If H(<H^>,<H^>) -> H.Qn, then H^(<H^>) also -> H^.Qn,
and Halts, thus H was wrong. This is by the CORRECT definition of
Halting, not your broken definitiion.

>
> It is true that the halt status of the actual behavior of the actual
> input is correctly determined on the basis of whether or not the correct
> simulation of the inputs by a simulating halt decider can possibly reach
> a final state of this simulated input.

Wrong, H is NOT a correct simulation if it aborts its simulation.
PERIOD. THe correct answer is determined by what an ACTUAL UTM or the
ACUTAL machine does.

FAIL.

>
> These things are known to be true on the basis of the meaning of their
> words.
>

PROVE your statement, just try. Not by some sbstract 'Meaning of the
Words' but from the actual FORMAL definition and accepted proofs. You
can't, and you are lying when you claim you can, until you actually
present it.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 17:12:04 -0600
Date: Sun, 30 Jan 2022 17:12:01 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<F5udnWZWAajYx278nZ2dnUU7-dfNnZ2d@giganews.com>
<g%IIJ.21397$1_.9729@fx37.iad> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <osEJJ.11004$uP.10312@fx16.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
Lines: 133
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-45up7RiF0DmkTYnWk66khu+UkXnglWs3zkaV5JQKbMrSg08NT8xlhaWzGAezDXBYb5VKLWetssBKFd8!TJ4j8Ztv5dA0PYj0bUboPWjTDIqTQd4Nh49kWGpQwrHqf7AfXJG8fO4Hja40O0FJGz1vHPfZ+rjK
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7454
 by: olcott - Sun, 30 Jan 2022 23:12 UTC

On 1/30/2022 4:39 PM, Richard Damon wrote:
> On 1/30/22 4:21 PM, olcott wrote:
>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>> On 1/30/22 3:09 PM, olcott wrote:
>>
>>>> Because all simulating halt deciders are deciders they are only
>>>> accountable for computing the mapping from their input finite
>>>> strings to an accept or reject state on the basis of whether or not
>>>> their correct simulation of this input can possibly reach the final
>>>> state of this simulated input in any finite number of steps.
>>>>
>>>> It is like you put a guard on the front door that is supposed to
>>>> report anyone coming in the front door (the actual inputs). Then
>>>> someone comes in the back door (non inputs) and the guard does not
>>>> report this. Since the guard is only supposed to report people
>>>> coming in the front door it is incorrect to say that the guard made
>>>> a mistake by not reporting people that came in the back door.
>>>>
>>>> embedded_H is not supposed to report on the halt status of the
>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>
>>>>
>>>
>>> So, you have just admitted that you aren't working on the Halting
>>> Problem, so any claims therein are just lies.
>>>
>>> Since the definition of the Halting Problem refers to the ACTUAL
>>> behavior of the machine the input represents, and NOT the partial
>>> simulation that some simulating halt decider might do, you are
>>> admitting that you H is NOT using the Halting Problem definition and
>>> thus your claims that your results apply to the Halting problem are
>>> just lies.
>>>
>>> For the Halting Problem, the correct results for the inputs is based
>>> on the actual behavior of the machine, or its equivalent the
>>> simulation of the input with a REAL UTM. Thus the 'Front Door' to the
>>> problem s based on that, so either you your guards are lying or, what
>>> seems more likely, you posted them to the wrong door.
>>>
>>> You have basically just proved that you have totally wasted the last
>>> years of your life, as you have been working on the wrong problem,
>>> because you just don't understand what the problem you wanted to
>>> solve actually was.
>>>
>>> FAIL.
>>
>> Sum(int X, int Y) { return X + Y );
>>
>> It is true that halt deciders must report on the actual behavior of
>> their actual inputs in the same way that Sum(2,5) must return 7.
>
> Right, and the correct answer for if H(wM, w) should report halting is
> if M x will reach a final state in a finite number of steps. This is
> identical to if UTM(wM, w) will halt. Dosn't matter what you think
> otherwise, that IS the definition of the actual behavior.
>
> It is NOT something based on the partial simulation that H does.
>

The you cannot understand how all kinds of infinite behavior patterns
can be easily recognized in a finite number of steps is not any mistake
on my part:

_Infinite_Recursion()
[00000926](01) 55 push ebp
[00000927](02) 8bec mov ebp,esp
[00000929](03) 8b4508 mov eax,[ebp+08]
[0000092c](01) 50 push eax
[0000092d](05) e8f4ffffff call 00000926
[00000932](03) 83c404 add esp,+04
[00000935](01) 5d pop ebp
[00000936](01) c3 ret
Size in bytes:(0017) [00000936]

_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]

> PERIOD.
>
> FAIL.
>
> It is proven that If H(<H^>,<H^>) -> H.Qn, then H^(<H^>) also -> H^.Qn,
> and Halts, thus H was wrong. This is by the CORRECT definition of
> Halting, not your broken definitiion.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

simulated ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn cannot possibly occur therefore
the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never halts.

>>
>> It is true that the halt status of the actual behavior of the actual
>> input is correctly determined on the basis of whether or not the
>> correct simulation of the inputs by a simulating halt decider can
>> possibly reach a final state of this simulated input.
>
> Wrong, H is NOT a correct simulation if it aborts its simulation.
> PERIOD. THe correct answer is determined by what an ACTUAL UTM or the
> ACUTAL machine does.
>
> FAIL.
>
>>
>> These things are known to be true on the basis of the meaning of their
>> words.
>>
>
> PROVE your statement, just try. Not by some sbstract 'Meaning of the
> Words' but from the actual FORMAL definition and accepted proofs. You
> can't, and you are lying when you claim you can, until you actually
> present it.
>

I can't prove anything to you because you reject verified facts such as
the fact that a correct definition of halting is reaching a final state:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<ecFJJ.19021$mS1.7877@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.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.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <g%IIJ.21397$1_.9729@fx37.iad>
<ssvnfc$4lt$2@dont-email.me> <vEJIJ.5949$rU.2844@fx34.iad>
<n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 168
Message-ID: <ecFJJ.19021$mS1.7877@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: Sun, 30 Jan 2022 18:30:18 -0500
X-Received-Bytes: 8573
 by: Richard Damon - Sun, 30 Jan 2022 23:30 UTC

On 1/30/22 6:12 PM, olcott wrote:
> On 1/30/2022 4:39 PM, Richard Damon wrote:
>> On 1/30/22 4:21 PM, olcott wrote:
>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>
>>>>> Because all simulating halt deciders are deciders they are only
>>>>> accountable for computing the mapping from their input finite
>>>>> strings to an accept or reject state on the basis of whether or not
>>>>> their correct simulation of this input can possibly reach the final
>>>>> state of this simulated input in any finite number of steps.
>>>>>
>>>>> It is like you put a guard on the front door that is supposed to
>>>>> report anyone coming in the front door (the actual inputs). Then
>>>>> someone comes in the back door (non inputs) and the guard does not
>>>>> report this. Since the guard is only supposed to report people
>>>>> coming in the front door it is incorrect to say that the guard made
>>>>> a mistake by not reporting people that came in the back door.
>>>>>
>>>>> embedded_H is not supposed to report on the halt status of the
>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>
>>>>>
>>>>
>>>> So, you have just admitted that you aren't working on the Halting
>>>> Problem, so any claims therein are just lies.
>>>>
>>>> Since the definition of the Halting Problem refers to the ACTUAL
>>>> behavior of the machine the input represents, and NOT the partial
>>>> simulation that some simulating halt decider might do, you are
>>>> admitting that you H is NOT using the Halting Problem definition and
>>>> thus your claims that your results apply to the Halting problem are
>>>> just lies.
>>>>
>>>> For the Halting Problem, the correct results for the inputs is based
>>>> on the actual behavior of the machine, or its equivalent the
>>>> simulation of the input with a REAL UTM. Thus the 'Front Door' to
>>>> the problem s based on that, so either you your guards are lying or,
>>>> what seems more likely, you posted them to the wrong door.
>>>>
>>>> You have basically just proved that you have totally wasted the last
>>>> years of your life, as you have been working on the wrong problem,
>>>> because you just don't understand what the problem you wanted to
>>>> solve actually was.
>>>>
>>>> FAIL.
>>>
>>> Sum(int X, int Y) { return X + Y );
>>>
>>> It is true that halt deciders must report on the actual behavior of
>>> their actual inputs in the same way that Sum(2,5) must return 7.
>>
>> Right, and the correct answer for if H(wM, w) should report halting is
>> if M x will reach a final state in a finite number of steps. This is
>> identical to if UTM(wM, w) will halt. Dosn't matter what you think
>> otherwise, that IS the definition of the actual behavior.
>>
>> It is NOT something based on the partial simulation that H does.
>>
>
> The you cannot understand how all kinds of infinite behavior patterns
> can be easily recognized in a finite number of steps is not any mistake
> on my part:

Yes, MANY can, but not ALL.

If you need to change the definition, then you are not working on the
halting problem.

>
> _Infinite_Recursion()
> [00000926](01)  55              push ebp
> [00000927](02)  8bec            mov ebp,esp
> [00000929](03)  8b4508          mov eax,[ebp+08]
> [0000092c](01)  50              push eax
> [0000092d](05)  e8f4ffffff      call 00000926
> [00000932](03)  83c404          add esp,+04
> [00000935](01)  5d              pop ebp
> [00000936](01)  c3              ret
> Size in bytes:(0017) [00000936]
>
> _Infinite_Loop()
> [00000946](01)  55              push ebp
> [00000947](02)  8bec            mov ebp,esp
> [00000949](02)  ebfe            jmp 00000949
> [0000094b](01)  5d              pop ebp
> [0000094c](01)  c3              ret
> Size in bytes:(0007) [0000094c]
>
>
>> PERIOD.
>>
>> FAIL.
>>
>> It is proven that If H(<H^>,<H^>) -> H.Qn, then H^(<H^>) also ->
>> H^.Qn, and Halts, thus H was wrong. This is by the CORRECT definition
>> of Halting, not your broken definitiion.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> simulated ⟨Ĥ⟩ ⊢* ⟨Ĥ⟩.qn cannot possibly occur therefore
> the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never halts.

???

You can't just simulate a representation of a machine, you need to
simulate the match plus input, so you ar stating non-sense.

And UTM(<H^>,<H^>) WILL simulate to H^.Qn as shown if H(<H^>,<H^>)->H.Qn
to be correct, as has been previously shown.

The fact that the simulation in H can't get there because it aborted too
soon proves nothing.

Yes, in the case where H is defined so that it doesn't abort then you
can prove that H^(<H^>) is non-halting, but the H for that case never
answers, so is still wrong.

Remember, H^ depends on H, so you get different one for every H, and
you thus need to pair the H with the H^ built from it, whose copy of H
acts just like it.

FAIL.

>
>>>
>>> It is true that the halt status of the actual behavior of the actual
>>> input is correctly determined on the basis of whether or not the
>>> correct simulation of the inputs by a simulating halt decider can
>>> possibly reach a final state of this simulated input.
>>
>> Wrong, H is NOT a correct simulation if it aborts its simulation.
>> PERIOD. THe correct answer is determined by what an ACTUAL UTM or the
>> ACUTAL machine does.
>>
>> FAIL.
>>
>>>
>>> These things are known to be true on the basis of the meaning of
>>> their words.
>>>
>>
>> PROVE your statement, just try. Not by some sbstract 'Meaning of the
>> Words' but from the actual FORMAL definition and accepted proofs. You
>> can't, and you are lying when you claim you can, until you actually
>> present it.
>>
>
> I can't prove anything to you because you reject verified facts such as
> the fact that a correct definition of halting is reaching a final state:

No. I accept that reaching the final state is Halting, you just want to
make it of the wrong thing. The definition is of the DIRECT running of
the machine, or by equivalency the REAL UTM of the input.

You keep wanting it to be the possibly aborted simulation of H of its
input, which is incorrect.

FAIL!

>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
>

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 17:35:58 -0600
Date: Sun, 30 Jan 2022 17:35:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <ssvnfc$4lt$2@dont-email.me>
<vEJIJ.5949$rU.2844@fx34.iad> <n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ecFJJ.19021$mS1.7877@fx10.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
Lines: 87
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-125Fsh9E2NegWANrPYtsXFDnRvX64+SwwWKRCfILZUoVTSvohQCjYRoAGm6ItVCtNpAiB+bFcX0k+7c!mhAlXxjSVqhNcHCuNzZnflnM5jgR05HuYanh/2KWI8n9ayEGo/+v5AoDWBRo+jjMLCMCmXN2YaW4
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5883
 by: olcott - Sun, 30 Jan 2022 23:35 UTC

On 1/30/2022 5:30 PM, Richard Damon wrote:
> On 1/30/22 6:12 PM, olcott wrote:
>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>> On 1/30/22 4:21 PM, olcott wrote:
>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>
>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>> accountable for computing the mapping from their input finite
>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>> not their correct simulation of this input can possibly reach the
>>>>>> final state of this simulated input in any finite number of steps.
>>>>>>
>>>>>> It is like you put a guard on the front door that is supposed to
>>>>>> report anyone coming in the front door (the actual inputs). Then
>>>>>> someone comes in the back door (non inputs) and the guard does not
>>>>>> report this. Since the guard is only supposed to report people
>>>>>> coming in the front door it is incorrect to say that the guard
>>>>>> made a mistake by not reporting people that came in the back door.
>>>>>>
>>>>>> embedded_H is not supposed to report on the halt status of the
>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>
>>>>>>
>>>>>
>>>>> So, you have just admitted that you aren't working on the Halting
>>>>> Problem, so any claims therein are just lies.
>>>>>
>>>>> Since the definition of the Halting Problem refers to the ACTUAL
>>>>> behavior of the machine the input represents, and NOT the partial
>>>>> simulation that some simulating halt decider might do, you are
>>>>> admitting that you H is NOT using the Halting Problem definition
>>>>> and thus your claims that your results apply to the Halting problem
>>>>> are just lies.
>>>>>
>>>>> For the Halting Problem, the correct results for the inputs is
>>>>> based on the actual behavior of the machine, or its equivalent the
>>>>> simulation of the input with a REAL UTM. Thus the 'Front Door' to
>>>>> the problem s based on that, so either you your guards are lying
>>>>> or, what seems more likely, you posted them to the wrong door.
>>>>>
>>>>> You have basically just proved that you have totally wasted the
>>>>> last years of your life, as you have been working on the wrong
>>>>> problem, because you just don't understand what the problem you
>>>>> wanted to solve actually was.
>>>>>
>>>>> FAIL.
>>>>
>>>> Sum(int X, int Y) { return X + Y );
>>>>
>>>> It is true that halt deciders must report on the actual behavior of
>>>> their actual inputs in the same way that Sum(2,5) must return 7.
>>>
>>> Right, and the correct answer for if H(wM, w) should report halting
>>> is if M x will reach a final state in a finite number of steps. This
>>> is identical to if UTM(wM, w) will halt. Dosn't matter what you think
>>> otherwise, that IS the definition of the actual behavior.
>>>
>>> It is NOT something based on the partial simulation that H does.
>>>
>>
>> The you cannot understand how all kinds of infinite behavior patterns
>> can be easily recognized in a finite number of steps is not any
>> mistake on my part:
>
> Yes, MANY can, but not ALL.
>
> If you need to change the definition, then you are not working on the
> halting problem.
>
>

I don't have to change the definition I merely make it much more precise:

(1) Halting is defined as reaching a final state.

(2) Halt deciders like all deciders can and must ignore everything that
is not a direct input.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<7FFJJ.29151$541.18496@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news.uzoreto.com!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<n42dnQN47syP9W78nZ2dnUU7-LXNnZ2d@giganews.com>
<d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 116
Message-ID: <7FFJJ.29151$541.18496@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 19:01:07 -0500
X-Received-Bytes: 7035
 by: Richard Damon - Mon, 31 Jan 2022 00:01 UTC

On 1/30/22 6:35 PM, olcott wrote:
> On 1/30/2022 5:30 PM, Richard Damon wrote:
>> On 1/30/22 6:12 PM, olcott wrote:
>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>
>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>> accountable for computing the mapping from their input finite
>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>> not their correct simulation of this input can possibly reach the
>>>>>>> final state of this simulated input in any finite number of steps.
>>>>>>>
>>>>>>> It is like you put a guard on the front door that is supposed to
>>>>>>> report anyone coming in the front door (the actual inputs). Then
>>>>>>> someone comes in the back door (non inputs) and the guard does
>>>>>>> not report this. Since the guard is only supposed to report
>>>>>>> people coming in the front door it is incorrect to say that the
>>>>>>> guard made a mistake by not reporting people that came in the
>>>>>>> back door.
>>>>>>>
>>>>>>> embedded_H is not supposed to report on the halt status of the
>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So, you have just admitted that you aren't working on the Halting
>>>>>> Problem, so any claims therein are just lies.
>>>>>>
>>>>>> Since the definition of the Halting Problem refers to the ACTUAL
>>>>>> behavior of the machine the input represents, and NOT the partial
>>>>>> simulation that some simulating halt decider might do, you are
>>>>>> admitting that you H is NOT using the Halting Problem definition
>>>>>> and thus your claims that your results apply to the Halting
>>>>>> problem are just lies.
>>>>>>
>>>>>> For the Halting Problem, the correct results for the inputs is
>>>>>> based on the actual behavior of the machine, or its equivalent the
>>>>>> simulation of the input with a REAL UTM. Thus the 'Front Door' to
>>>>>> the problem s based on that, so either you your guards are lying
>>>>>> or, what seems more likely, you posted them to the wrong door.
>>>>>>
>>>>>> You have basically just proved that you have totally wasted the
>>>>>> last years of your life, as you have been working on the wrong
>>>>>> problem, because you just don't understand what the problem you
>>>>>> wanted to solve actually was.
>>>>>>
>>>>>> FAIL.
>>>>>
>>>>> Sum(int X, int Y) { return X + Y );
>>>>>
>>>>> It is true that halt deciders must report on the actual behavior of
>>>>> their actual inputs in the same way that Sum(2,5) must return 7.
>>>>
>>>> Right, and the correct answer for if H(wM, w) should report halting
>>>> is if M x will reach a final state in a finite number of steps. This
>>>> is identical to if UTM(wM, w) will halt. Dosn't matter what you
>>>> think otherwise, that IS the definition of the actual behavior.
>>>>
>>>> It is NOT something based on the partial simulation that H does.
>>>>
>>>
>>> The you cannot understand how all kinds of infinite behavior patterns
>>> can be easily recognized in a finite number of steps is not any
>>> mistake on my part:
>>
>> Yes, MANY can, but not ALL.
>>
>> If you need to change the definition, then you are not working on the
>> halting problem.
>>
>>
>
> I don't have to change the definition I merely make it much more precise:

Except that the original definition IS exactly precise. The is a single
WELL DEFINED answer for any instance of the question. The fact that you
see some abiguity just shows you don't really understand the field.

>
> (1) Halting is defined as reaching a final state.

But you change the 'of what'. The Actual definition states it is the
ACTUAL COMPUTATION that the input represents reaches the final state.

The Definition of a UTM says that an ACTUAL UTM of the input will behave
the same.

YOU want to make it of the 'not quite' UTM of H as the decision, which
isn't quite the Computation in question.

FAIL.

>
> (2) Halt deciders like all deciders can and must ignore everything that
> is not a direct input.
>

And the 'direct input' of <H^> <H^> directly refers to the computation
of H^ applied to <H^> by DEFINITION.

The fact that you want it to means something else just shows that you
are not ACTUALLY working on the Halting Problem.

Now, you do have one point, but miss the meaning, that by the nature of
Turing Machines, H doesn't actually have access to the behavior of the
actual machine or the results of the UTM simulation of its input. THAT
IS WHY IT IS A PROBLEM. If H could just use the UTM, and actually see if
it will halt or not in finite time, it would be simple. But the problem
is the problem as stated, because THAT IS the problem that needs to be
solved. It turns out this is why you can't actually make a accurate Halt
Decider, because the problem it needs to actually solve is just too hard.

So, you FAIL.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<st7a2e$oo$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic sci.math comp.ai.philosophy
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,sci.math,comp.ai.philosophy
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Followup-To: comp.theory
Date: Sun, 30 Jan 2022 18:21:31 -0600
Organization: A noiseless patient Spider
Lines: 119
Message-ID: <st7a2e$oo$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me> <d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 31 Jan 2022 00:21:34 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="e4aef017c60113144c86a33a4df4f7d0";
logging-data="792"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+PrPZmbTqxLYHYzDnnelHg"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:OtYwhKhkWeL0jOFm3n+dIGTklEE=
In-Reply-To: <7FFJJ.29151$541.18496@fx35.iad>
Content-Language: en-US
 by: olcott - Mon, 31 Jan 2022 00:21 UTC

On 1/30/2022 6:01 PM, Richard Damon wrote:
> On 1/30/22 6:35 PM, olcott wrote:
>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>> On 1/30/22 6:12 PM, olcott wrote:
>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>
>>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>>> accountable for computing the mapping from their input finite
>>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>>> not their correct simulation of this input can possibly reach
>>>>>>>> the final state of this simulated input in any finite number of
>>>>>>>> steps.
>>>>>>>>
>>>>>>>> It is like you put a guard on the front door that is supposed to
>>>>>>>> report anyone coming in the front door (the actual inputs). Then
>>>>>>>> someone comes in the back door (non inputs) and the guard does
>>>>>>>> not report this. Since the guard is only supposed to report
>>>>>>>> people coming in the front door it is incorrect to say that the
>>>>>>>> guard made a mistake by not reporting people that came in the
>>>>>>>> back door.
>>>>>>>>
>>>>>>>> embedded_H is not supposed to report on the halt status of the
>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, you have just admitted that you aren't working on the Halting
>>>>>>> Problem, so any claims therein are just lies.
>>>>>>>
>>>>>>> Since the definition of the Halting Problem refers to the ACTUAL
>>>>>>> behavior of the machine the input represents, and NOT the partial
>>>>>>> simulation that some simulating halt decider might do, you are
>>>>>>> admitting that you H is NOT using the Halting Problem definition
>>>>>>> and thus your claims that your results apply to the Halting
>>>>>>> problem are just lies.
>>>>>>>
>>>>>>> For the Halting Problem, the correct results for the inputs is
>>>>>>> based on the actual behavior of the machine, or its equivalent
>>>>>>> the simulation of the input with a REAL UTM. Thus the 'Front
>>>>>>> Door' to the problem s based on that, so either you your guards
>>>>>>> are lying or, what seems more likely, you posted them to the
>>>>>>> wrong door.
>>>>>>>
>>>>>>> You have basically just proved that you have totally wasted the
>>>>>>> last years of your life, as you have been working on the wrong
>>>>>>> problem, because you just don't understand what the problem you
>>>>>>> wanted to solve actually was.
>>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>
>>>>>> It is true that halt deciders must report on the actual behavior
>>>>>> of their actual inputs in the same way that Sum(2,5) must return 7.
>>>>>
>>>>> Right, and the correct answer for if H(wM, w) should report halting
>>>>> is if M x will reach a final state in a finite number of steps.
>>>>> This is identical to if UTM(wM, w) will halt. Dosn't matter what
>>>>> you think otherwise, that IS the definition of the actual behavior.
>>>>>
>>>>> It is NOT something based on the partial simulation that H does.
>>>>>
>>>>
>>>> The you cannot understand how all kinds of infinite behavior
>>>> patterns can be easily recognized in a finite number of steps is not
>>>> any mistake on my part:
>>>
>>> Yes, MANY can, but not ALL.
>>>
>>> If you need to change the definition, then you are not working on the
>>> halting problem.
>>>
>>>
>>
>> I don't have to change the definition I merely make it much more precise:
>
> Except that the original definition IS exactly precise. The is a single
> WELL DEFINED answer for any instance of the question. The fact that you
> see some abiguity just shows you don't really understand the field.
>
>>
>> (1) Halting is defined as reaching a final state.
>
> But you change the 'of what'.

A directly executed TM halts when it reaches the final state of this
directly executed TM.

A simulated TM description halts when the simulated TM description
reaches it final state.

If you weren't focused on rebuttal and instead focused on truth you
would have agreed to this long ago.

>> (2) Halt deciders like all deciders can and must ignore everything
>> that is not a direct input.
>>
>
> And the 'direct input' of <H^> <H^> directly refers to the computation
> of H^ applied to <H^> by DEFINITION.
>

Stupidly WRONG !!!

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The direct input to embedded_H is ⟨Ĥ⟩ ⟨Ĥ⟩ and is not Ĥ applied to ⟨Ĥ⟩.

If you weren't focused on rebuttal and instead focused on truth you
would have agreed to this long ago.

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<ibHJJ.56320$u41.55552@fx41.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx41.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <d2KIJ.24507$541.2175@fx35.iad>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <st7a2e$oo$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 156
Message-ID: <ibHJJ.56320$u41.55552@fx41.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 20:45:50 -0500
X-Received-Bytes: 8236
 by: Richard Damon - Mon, 31 Jan 2022 01:45 UTC

On 1/30/22 7:21 PM, olcott wrote:
> On 1/30/2022 6:01 PM, Richard Damon wrote:
>> On 1/30/22 6:35 PM, olcott wrote:
>>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>>> On 1/30/22 6:12 PM, olcott wrote:
>>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>>
>>>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>>>> accountable for computing the mapping from their input finite
>>>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>>>> not their correct simulation of this input can possibly reach
>>>>>>>>> the final state of this simulated input in any finite number of
>>>>>>>>> steps.
>>>>>>>>>
>>>>>>>>> It is like you put a guard on the front door that is supposed
>>>>>>>>> to report anyone coming in the front door (the actual inputs).
>>>>>>>>> Then someone comes in the back door (non inputs) and the guard
>>>>>>>>> does not report this. Since the guard is only supposed to
>>>>>>>>> report people coming in the front door it is incorrect to say
>>>>>>>>> that the guard made a mistake by not reporting people that came
>>>>>>>>> in the back door.
>>>>>>>>>
>>>>>>>>> embedded_H is not supposed to report on the halt status of the
>>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you have just admitted that you aren't working on the
>>>>>>>> Halting Problem, so any claims therein are just lies.
>>>>>>>>
>>>>>>>> Since the definition of the Halting Problem refers to the ACTUAL
>>>>>>>> behavior of the machine the input represents, and NOT the
>>>>>>>> partial simulation that some simulating halt decider might do,
>>>>>>>> you are admitting that you H is NOT using the Halting Problem
>>>>>>>> definition and thus your claims that your results apply to the
>>>>>>>> Halting problem are just lies.
>>>>>>>>
>>>>>>>> For the Halting Problem, the correct results for the inputs is
>>>>>>>> based on the actual behavior of the machine, or its equivalent
>>>>>>>> the simulation of the input with a REAL UTM. Thus the 'Front
>>>>>>>> Door' to the problem s based on that, so either you your guards
>>>>>>>> are lying or, what seems more likely, you posted them to the
>>>>>>>> wrong door.
>>>>>>>>
>>>>>>>> You have basically just proved that you have totally wasted the
>>>>>>>> last years of your life, as you have been working on the wrong
>>>>>>>> problem, because you just don't understand what the problem you
>>>>>>>> wanted to solve actually was.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>
>>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>>
>>>>>>> It is true that halt deciders must report on the actual behavior
>>>>>>> of their actual inputs in the same way that Sum(2,5) must return 7.
>>>>>>
>>>>>> Right, and the correct answer for if H(wM, w) should report
>>>>>> halting is if M x will reach a final state in a finite number of
>>>>>> steps. This is identical to if UTM(wM, w) will halt. Dosn't matter
>>>>>> what you think otherwise, that IS the definition of the actual
>>>>>> behavior.
>>>>>>
>>>>>> It is NOT something based on the partial simulation that H does.
>>>>>>
>>>>>
>>>>> The you cannot understand how all kinds of infinite behavior
>>>>> patterns can be easily recognized in a finite number of steps is
>>>>> not any mistake on my part:
>>>>
>>>> Yes, MANY can, but not ALL.
>>>>
>>>> If you need to change the definition, then you are not working on
>>>> the halting problem.
>>>>
>>>>
>>>
>>> I don't have to change the definition I merely make it much more
>>> precise:
>>
>> Except that the original definition IS exactly precise. The is a
>> single WELL DEFINED answer for any instance of the question. The fact
>> that you see some abiguity just shows you don't really understand the
>> field.
>>
>>>
>>> (1) Halting is defined as reaching a final state.
>>
>> But you change the 'of what'.
>
> A directly executed TM halts when it reaches the final state of this
> directly executed TM.
>
> A simulated TM description halts when the simulated TM description
> reaches it final state.
>

Right, but if the simulator isn't a real UTM and stops simulating, the
'pure simulation' continues until it either halts or runs for ever.

> If you weren't focused on rebuttal and instead focused on truth you
> would have agreed to this long ago.

No, the only 'simulator' that counts for this is the simulator that
doesn't stop until it reaches the final state or runs forever, and thus
it is NOT H, if H can abort it simulation.

If you would stop and think about what you are saying maybe you would
learn something.

>
>>> (2) Halt deciders like all deciders can and must ignore everything
>>> that is not a direct input.
>>>
>>
>> And the 'direct input' of <H^> <H^> directly refers to the computation
>> of H^ applied to <H^> by DEFINITION.
>>
>
> Stupidly WRONG !!!
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

These statements need the conditions, that H^ goes to H^.Qy/H^.Qn iff H
goes to that corresponding state.

>
> The direct input to embedded_H is ⟨Ĥ⟩ ⟨Ĥ⟩ and is not Ĥ applied to ⟨Ĥ⟩.

And the behvior of the input <H^> <H^> is the behavior of H^ applied to
<H^>.

IF not, you aren't doing the Halting Problem.

Remember, if the H embedded in H^ maps H <H^> <H^> -> H.Qn as you claim
is the correct answer, then by the construction of H^, H^ <H^> -> H^.Qn
and Halts, thus H did NOT give the correct answer as the definition of
the requirements on H was that H <H^> <H^> goes to H.Qn ONLY IF H^
applied to <H^> never halts (not the simulation in H/H^, but the actual
machine).

This means that for ANY H, H <H^> <H^> -> H.Qn is NEVER the right
answer, as if H does that, then H^ <H^&> will Halt and thus H.Qn was not
the right answer.

>
> If you weren't focused on rebuttal and instead focused on truth you
> would have agreed to this long ago.
>
>

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 30 Jan 2022 20:05:52 -0600
Date: Sun, 30 Jan 2022 20:05:50 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<4KSdnY1xDqmF8m78nZ2dnUU7-dnNnZ2d@giganews.com>
<QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
<ibHJJ.56320$u41.55552@fx41.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ibHJJ.56320$u41.55552@fx41.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
Lines: 145
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sVwV3bi6Q/IUQH6vWzkFY7+p2b1ui1Rf+NlMD7MRh+IXVmyvw6xBSI/CKkW3jzyCreJjwW3wR5ViRw7!TrNa31bO659/hCgPyacYna1jRL4KA/7+br6tWVaXRNlayqA9lrIUk81imDuaI0PTUl8I+9ER3nnT
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7979
 by: olcott - Mon, 31 Jan 2022 02:05 UTC

On 1/30/2022 7:45 PM, Richard Damon wrote:
> On 1/30/22 7:21 PM, olcott wrote:
>> On 1/30/2022 6:01 PM, Richard Damon wrote:
>>> On 1/30/22 6:35 PM, olcott wrote:
>>>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>>>> On 1/30/22 6:12 PM, olcott wrote:
>>>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>>>
>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>> whether or not their correct simulation of this input can
>>>>>>>>>> possibly reach the final state of this simulated input in any
>>>>>>>>>> finite number of steps.
>>>>>>>>>>
>>>>>>>>>> It is like you put a guard on the front door that is supposed
>>>>>>>>>> to report anyone coming in the front door (the actual inputs).
>>>>>>>>>> Then someone comes in the back door (non inputs) and the guard
>>>>>>>>>> does not report this. Since the guard is only supposed to
>>>>>>>>>> report people coming in the front door it is incorrect to say
>>>>>>>>>> that the guard made a mistake by not reporting people that
>>>>>>>>>> came in the back door.
>>>>>>>>>>
>>>>>>>>>> embedded_H is not supposed to report on the halt status of the
>>>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, you have just admitted that you aren't working on the
>>>>>>>>> Halting Problem, so any claims therein are just lies.
>>>>>>>>>
>>>>>>>>> Since the definition of the Halting Problem refers to the
>>>>>>>>> ACTUAL behavior of the machine the input represents, and NOT
>>>>>>>>> the partial simulation that some simulating halt decider might
>>>>>>>>> do, you are admitting that you H is NOT using the Halting
>>>>>>>>> Problem definition and thus your claims that your results apply
>>>>>>>>> to the Halting problem are just lies.
>>>>>>>>>
>>>>>>>>> For the Halting Problem, the correct results for the inputs is
>>>>>>>>> based on the actual behavior of the machine, or its equivalent
>>>>>>>>> the simulation of the input with a REAL UTM. Thus the 'Front
>>>>>>>>> Door' to the problem s based on that, so either you your guards
>>>>>>>>> are lying or, what seems more likely, you posted them to the
>>>>>>>>> wrong door.
>>>>>>>>>
>>>>>>>>> You have basically just proved that you have totally wasted the
>>>>>>>>> last years of your life, as you have been working on the wrong
>>>>>>>>> problem, because you just don't understand what the problem you
>>>>>>>>> wanted to solve actually was.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>>>
>>>>>>>> It is true that halt deciders must report on the actual behavior
>>>>>>>> of their actual inputs in the same way that Sum(2,5) must return 7.
>>>>>>>
>>>>>>> Right, and the correct answer for if H(wM, w) should report
>>>>>>> halting is if M x will reach a final state in a finite number of
>>>>>>> steps. This is identical to if UTM(wM, w) will halt. Dosn't
>>>>>>> matter what you think otherwise, that IS the definition of the
>>>>>>> actual behavior.
>>>>>>>
>>>>>>> It is NOT something based on the partial simulation that H does.
>>>>>>>
>>>>>>
>>>>>> The you cannot understand how all kinds of infinite behavior
>>>>>> patterns can be easily recognized in a finite number of steps is
>>>>>> not any mistake on my part:
>>>>>
>>>>> Yes, MANY can, but not ALL.
>>>>>
>>>>> If you need to change the definition, then you are not working on
>>>>> the halting problem.
>>>>>
>>>>>
>>>>
>>>> I don't have to change the definition I merely make it much more
>>>> precise:
>>>
>>> Except that the original definition IS exactly precise. The is a
>>> single WELL DEFINED answer for any instance of the question. The fact
>>> that you see some abiguity just shows you don't really understand the
>>> field.
>>>
>>>>
>>>> (1) Halting is defined as reaching a final state.
>>>
>>> But you change the 'of what'.
>>
>> A directly executed TM halts when it reaches the final state of this
>> directly executed TM.
>>
>> A simulated TM description halts when the simulated TM description
>> reaches it final state.
>>
>
> Right, but if the simulator isn't a real UTM and stops simulating, the
> 'pure simulation' continues until it either halts or runs for ever.
>

H.q0 Wm W ⊢* H.qy
iff UTM Wm W reaches its final state

H.q0 Wm W ⊢* H.qn
iff UTM Wm W never reaches its final state

>>>> (2) Halt deciders like all deciders can and must ignore everything
>>>> that is not a direct input.
>>>>
>>>
>>> And the 'direct input' of <H^> <H^> directly refers to the
>>> computation of H^ applied to <H^> by DEFINITION.
>>>
>>
>> Stupidly WRONG !!!
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn iff H
> goes to that corresponding state.
>

⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the same
way that (5,3) is syntactically specified as an input to Sum(5,3)

Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
same way that (1,2) is NOT syntactically specified as an input to Sum(5,3)

It this case you are simply a damned liar.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<gIHJJ.29153$541.4042@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <QRKIJ.10111$uP.9595@fx16.iad>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
<ibHJJ.56320$u41.55552@fx41.iad>
<hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 173
Message-ID: <gIHJJ.29153$541.4042@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 30 Jan 2022 21:20:59 -0500
X-Received-Bytes: 9159
X-Original-Bytes: 9026
 by: Richard Damon - Mon, 31 Jan 2022 02:20 UTC

On 1/30/22 9:05 PM, olcott wrote:
> On 1/30/2022 7:45 PM, Richard Damon wrote:
>> On 1/30/22 7:21 PM, olcott wrote:
>>> On 1/30/2022 6:01 PM, Richard Damon wrote:
>>>> On 1/30/22 6:35 PM, olcott wrote:
>>>>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>>>>> On 1/30/22 6:12 PM, olcott wrote:
>>>>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>> whether or not their correct simulation of this input can
>>>>>>>>>>> possibly reach the final state of this simulated input in any
>>>>>>>>>>> finite number of steps.
>>>>>>>>>>>
>>>>>>>>>>> It is like you put a guard on the front door that is supposed
>>>>>>>>>>> to report anyone coming in the front door (the actual
>>>>>>>>>>> inputs). Then someone comes in the back door (non inputs) and
>>>>>>>>>>> the guard does not report this. Since the guard is only
>>>>>>>>>>> supposed to report people coming in the front door it is
>>>>>>>>>>> incorrect to say that the guard made a mistake by not
>>>>>>>>>>> reporting people that came in the back door.
>>>>>>>>>>>
>>>>>>>>>>> embedded_H is not supposed to report on the halt status of
>>>>>>>>>>> the computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, you have just admitted that you aren't working on the
>>>>>>>>>> Halting Problem, so any claims therein are just lies.
>>>>>>>>>>
>>>>>>>>>> Since the definition of the Halting Problem refers to the
>>>>>>>>>> ACTUAL behavior of the machine the input represents, and NOT
>>>>>>>>>> the partial simulation that some simulating halt decider might
>>>>>>>>>> do, you are admitting that you H is NOT using the Halting
>>>>>>>>>> Problem definition and thus your claims that your results
>>>>>>>>>> apply to the Halting problem are just lies.
>>>>>>>>>>
>>>>>>>>>> For the Halting Problem, the correct results for the inputs is
>>>>>>>>>> based on the actual behavior of the machine, or its equivalent
>>>>>>>>>> the simulation of the input with a REAL UTM. Thus the 'Front
>>>>>>>>>> Door' to the problem s based on that, so either you your
>>>>>>>>>> guards are lying or, what seems more likely, you posted them
>>>>>>>>>> to the wrong door.
>>>>>>>>>>
>>>>>>>>>> You have basically just proved that you have totally wasted
>>>>>>>>>> the last years of your life, as you have been working on the
>>>>>>>>>> wrong problem, because you just don't understand what the
>>>>>>>>>> problem you wanted to solve actually was.
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>>>>
>>>>>>>>> It is true that halt deciders must report on the actual
>>>>>>>>> behavior of their actual inputs in the same way that Sum(2,5)
>>>>>>>>> must return 7.
>>>>>>>>
>>>>>>>> Right, and the correct answer for if H(wM, w) should report
>>>>>>>> halting is if M x will reach a final state in a finite number of
>>>>>>>> steps. This is identical to if UTM(wM, w) will halt. Dosn't
>>>>>>>> matter what you think otherwise, that IS the definition of the
>>>>>>>> actual behavior.
>>>>>>>>
>>>>>>>> It is NOT something based on the partial simulation that H does.
>>>>>>>>
>>>>>>>
>>>>>>> The you cannot understand how all kinds of infinite behavior
>>>>>>> patterns can be easily recognized in a finite number of steps is
>>>>>>> not any mistake on my part:
>>>>>>
>>>>>> Yes, MANY can, but not ALL.
>>>>>>
>>>>>> If you need to change the definition, then you are not working on
>>>>>> the halting problem.
>>>>>>
>>>>>>
>>>>>
>>>>> I don't have to change the definition I merely make it much more
>>>>> precise:
>>>>
>>>> Except that the original definition IS exactly precise. The is a
>>>> single WELL DEFINED answer for any instance of the question. The
>>>> fact that you see some abiguity just shows you don't really
>>>> understand the field.
>>>>
>>>>>
>>>>> (1) Halting is defined as reaching a final state.
>>>>
>>>> But you change the 'of what'.
>>>
>>> A directly executed TM halts when it reaches the final state of this
>>> directly executed TM.
>>>
>>> A simulated TM description halts when the simulated TM description
>>> reaches it final state.
>>>
>>
>> Right, but if the simulator isn't a real UTM and stops simulating, the
>> 'pure simulation' continues until it either halts or runs for ever.
>>
>
> H.q0 Wm W ⊢* H.qy
> iff UTM Wm W reaches its final state
>
> H.q0 Wm W ⊢* H.qn
> iff UTM Wm W never reaches its final state

Right, and that is the REAL UTM, not H playing one on TV and stopping
when it thinks it has an answer.
>
>>>>> (2) Halt deciders like all deciders can and must ignore everything
>>>>> that is not a direct input.
>>>>>
>>>>
>>>> And the 'direct input' of <H^> <H^> directly refers to the
>>>> computation of H^ applied to <H^> by DEFINITION.
>>>>
>>>
>>> Stupidly WRONG !!!
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn iff
>> H goes to that corresponding state.
>>
>
> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the same
> way that (5,3) is syntactically specified as an input to Sum(5,3)

Right, and the

>
> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
> same way that (1,2) is NOT syntactically specified as an input to Sum(5,3)

Right, but perhaps you don't understand that from you above statement
the right answer is based on if UTM(<H^>,<H^>) Halts which by the
definition of a UTM means if H^ applied to <H^> Halts.

Since you claim H <H^> <H^> -> H.Qn, then from the above definiton of
H^, we have that H^ <H^> also -> H^.Qn and Halts, so H is WRONG to go to
H.Qn, since we have that UTM(<H^>,<H^>) Halts since H^ applied to <H^>
Halts.

FAIL (can you show what is wrong with my logic?)
>
> It this case you are simply a damned liar.
>

Since you seem to want to claim that embedded_H is not responsible for
predicting if H^ applied to <H^>, THAT statement is in err.

embedded_H(<H^>.<H^>) is PRECISELY requried to report H.Qy if
UTM(<H^>,<H^>) will halt and H.Qn if it NEVER will, which is EXACTLY the
same as if H^ applied to <H^> will halt or not.


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

<st91ek$p4g$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Followup-To: comp.theory
Date: Mon, 31 Jan 2022 10:06:42 -0600
Organization: A noiseless patient Spider
Lines: 44
Message-ID: <st91ek$p4g$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
<ibHJJ.56320$u41.55552@fx41.iad>
<hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
<gIHJJ.29153$541.4042@fx35.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 31 Jan 2022 16:06:44 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="e4aef017c60113144c86a33a4df4f7d0";
logging-data="25744"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+7ul4OmT0oKgRYIPDx1emG"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:I2MIm3+Ip4ineUetVETXZyie+6k=
In-Reply-To: <gIHJJ.29153$541.4042@fx35.iad>
Content-Language: en-US
 by: olcott - Mon, 31 Jan 2022 16:06 UTC

On 1/30/2022 8:20 PM, Richard Damon wrote:
> On 1/30/22 9:05 PM, olcott wrote:

>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn iff
>>> H goes to that corresponding state.
>>>
>>
>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>
> Right, and the
>
>>
>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
>> same way that (1,2) is NOT syntactically specified as an input to
>> Sum(5,3)
>
>
> Right, but perhaps you don't understand that from you above statement
> the right answer is based on if UTM(<H^>,<H^>) Halts which by the
> definition of a UTM means if H^ applied to <H^> Halts.
>

The biggest reason for your huge mistakes is that you cannot stay
sharply focused on a single point. It is as if you either have attention
deficit disorder ADD or are addicted to methamphetamine.

>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.

After we have mutual agreement on this point we will move on to the
points that logically follow from this one.

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

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<st946r$oq0$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Followup-To: comp.theory
Date: Mon, 31 Jan 2022 10:53:45 -0600
Organization: A noiseless patient Spider
Lines: 184
Message-ID: <st946r$oq0$1@dont-email.me>
References: <ssh8vu$4c0$1@dont-email.me>
<v8udnTw-8aE_4G78nZ2dnUU7-cnNnZ2d@giganews.com>
<mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
<ibHJJ.56320$u41.55552@fx41.iad>
<hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
<gIHJJ.29153$541.4042@fx35.iad>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 31 Jan 2022 16:53:47 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="e4aef017c60113144c86a33a4df4f7d0";
logging-data="25408"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/veMeeTf1j0mtNRWVZIU1W"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Cancel-Lock: sha1:KOR0ov/ToMLHMbgp9opfiKNP+88=
In-Reply-To: <gIHJJ.29153$541.4042@fx35.iad>
Content-Language: en-US
 by: olcott - Mon, 31 Jan 2022 16:53 UTC

On 1/30/2022 8:20 PM, Richard Damon wrote:
> On 1/30/22 9:05 PM, olcott wrote:
>> On 1/30/2022 7:45 PM, Richard Damon wrote:
>>> On 1/30/22 7:21 PM, olcott wrote:
>>>> On 1/30/2022 6:01 PM, Richard Damon wrote:
>>>>> On 1/30/22 6:35 PM, olcott wrote:
>>>>>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>>>>>> On 1/30/22 6:12 PM, olcott wrote:
>>>>>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>>> whether or not their correct simulation of this input can
>>>>>>>>>>>> possibly reach the final state of this simulated input in
>>>>>>>>>>>> any finite number of steps.
>>>>>>>>>>>>
>>>>>>>>>>>> It is like you put a guard on the front door that is
>>>>>>>>>>>> supposed to report anyone coming in the front door (the
>>>>>>>>>>>> actual inputs). Then someone comes in the back door (non
>>>>>>>>>>>> inputs) and the guard does not report this. Since the guard
>>>>>>>>>>>> is only supposed to report people coming in the front door
>>>>>>>>>>>> it is incorrect to say that the guard made a mistake by not
>>>>>>>>>>>> reporting people that came in the back door.
>>>>>>>>>>>>
>>>>>>>>>>>> embedded_H is not supposed to report on the halt status of
>>>>>>>>>>>> the computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, you have just admitted that you aren't working on the
>>>>>>>>>>> Halting Problem, so any claims therein are just lies.
>>>>>>>>>>>
>>>>>>>>>>> Since the definition of the Halting Problem refers to the
>>>>>>>>>>> ACTUAL behavior of the machine the input represents, and NOT
>>>>>>>>>>> the partial simulation that some simulating halt decider
>>>>>>>>>>> might do, you are admitting that you H is NOT using the
>>>>>>>>>>> Halting Problem definition and thus your claims that your
>>>>>>>>>>> results apply to the Halting problem are just lies.
>>>>>>>>>>>
>>>>>>>>>>> For the Halting Problem, the correct results for the inputs
>>>>>>>>>>> is based on the actual behavior of the machine, or its
>>>>>>>>>>> equivalent the simulation of the input with a REAL UTM. Thus
>>>>>>>>>>> the 'Front Door' to the problem s based on that, so either
>>>>>>>>>>> you your guards are lying or, what seems more likely, you
>>>>>>>>>>> posted them to the wrong door.
>>>>>>>>>>>
>>>>>>>>>>> You have basically just proved that you have totally wasted
>>>>>>>>>>> the last years of your life, as you have been working on the
>>>>>>>>>>> wrong problem, because you just don't understand what the
>>>>>>>>>>> problem you wanted to solve actually was.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>>>>>
>>>>>>>>>> It is true that halt deciders must report on the actual
>>>>>>>>>> behavior of their actual inputs in the same way that Sum(2,5)
>>>>>>>>>> must return 7.
>>>>>>>>>
>>>>>>>>> Right, and the correct answer for if H(wM, w) should report
>>>>>>>>> halting is if M x will reach a final state in a finite number
>>>>>>>>> of steps. This is identical to if UTM(wM, w) will halt. Dosn't
>>>>>>>>> matter what you think otherwise, that IS the definition of the
>>>>>>>>> actual behavior.
>>>>>>>>>
>>>>>>>>> It is NOT something based on the partial simulation that H does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The you cannot understand how all kinds of infinite behavior
>>>>>>>> patterns can be easily recognized in a finite number of steps is
>>>>>>>> not any mistake on my part:
>>>>>>>
>>>>>>> Yes, MANY can, but not ALL.
>>>>>>>
>>>>>>> If you need to change the definition, then you are not working on
>>>>>>> the halting problem.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> I don't have to change the definition I merely make it much more
>>>>>> precise:
>>>>>
>>>>> Except that the original definition IS exactly precise. The is a
>>>>> single WELL DEFINED answer for any instance of the question. The
>>>>> fact that you see some abiguity just shows you don't really
>>>>> understand the field.
>>>>>
>>>>>>
>>>>>> (1) Halting is defined as reaching a final state.
>>>>>
>>>>> But you change the 'of what'.
>>>>
>>>> A directly executed TM halts when it reaches the final state of this
>>>> directly executed TM.
>>>>
>>>> A simulated TM description halts when the simulated TM description
>>>> reaches it final state.
>>>>
>>>
>>> Right, but if the simulator isn't a real UTM and stops simulating,
>>> the 'pure simulation' continues until it either halts or runs for ever.
>>>
>>
>> H.q0 Wm W ⊢* H.qy
>> iff UTM Wm W reaches its final state
>>
>> H.q0 Wm W ⊢* H.qn
>> iff UTM Wm W never reaches its final state
>
>
> Right, and that is the REAL UTM, not H playing one on TV and stopping
> when it thinks it has an answer.
As your scatterbrained mind keep repeating....
Yet I have kept correcting. It is not necessary for a simulating halt
decider to execute an infinite number of steps of an infinite sequence
of configurations for it to determine that a pure simulation of its
input would never stop running.

_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]

It is self-evident that the second time the instruction at [00000949] is
executed with no other instructions inbetween an infinite loop has been
recognized.

_Infinite_Recursion()
[00000926](01) 55 push ebp
[00000927](02) 8bec mov ebp,esp
[00000929](03) 8b4508 mov eax,[ebp+08]
[0000092c](01) 50 push eax
[0000092d](05) e8f4ffffff call 00000926
[00000932](03) 83c404 add esp,+04
[00000935](01) 5d pop ebp
[00000936](01) c3 ret
Size in bytes:(0017) [00000936]

Begin Local Halt Decider Simulation Execution Trace Stored at:211356

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000926][00211342][00211346] 55 push ebp
[00000927][00211342][00211346] 8bec mov ebp,esp
[00000929][00211342][00211346] 8b4508 mov eax,[ebp+08]
[0000092c][0021133e][00000777] 50 push eax
[0000092d][0021133a][00000932] e8f4ffffff call 00000926
[00000926][00211336][00211342] 55 push ebp
[00000927][00211336][00211342] 8bec mov ebp,esp
[00000929][00211336][00211342] 8b4508 mov eax,[ebp+08]
[0000092c][00211332][00000777] 50 push eax
[0000092d][0021132e][00000932] e8f4ffffff call 00000926
Local Halt Decider: Infinite Recursion Detected Simulation Stopped


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

<st9fn6$60s$2@gioia.aioe.org>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!42V55DPF/EHESwy7gmIc+w.user.46.165.242.75.POSTED!not-for-mail
From: ben_do...@yourmail.net (Ben)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Date: Mon, 31 Jan 2022 12:10:12 -0800
Organization: Aioe.org NNTP Server
Message-ID: <st9fn6$60s$2@gioia.aioe.org>
References: <ssh8vu$4c0$1@dont-email.me> <mIQIJ.34880$%T.27606@fx06.iad>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
<ibHJJ.56320$u41.55552@fx41.iad>
<hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
<gIHJJ.29153$541.4042@fx35.iad> <st91ek$p4g$1@dont-email.me>
Reply-To: ben_dover@yourmail.net
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="6172"; posting-host="42V55DPF/EHESwy7gmIc+w.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Ben - Mon, 31 Jan 2022 20:10 UTC

On 1/31/2022 8:06 AM, olcott wrote:
> On 1/30/2022 8:20 PM, Richard Damon wrote:
>> On 1/30/22 9:05 PM, olcott wrote:
>
>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn
>>>> iff H goes to that corresponding state.
>>>>
>>>
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>>
>> Right, and the
>>
>>>
>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
>>> same way that (1,2) is NOT syntactically specified as an input to
>>> Sum(5,3)
>>
>>
>> Right, but perhaps you don't understand that from you above statement
>> the right answer is based on if UTM(<H^>,<H^>) Halts which by the
>> definition of a UTM means if H^ applied to <H^> Halts.
>>
>
> The biggest reason for your huge mistakes is that you cannot stay
> sharply focused on a single point. It is as if you either have attention
> deficit disorder ADD or are addicted to methamphetamine.
>
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>
> After we have mutual agreement on this point we will move on to the
> points that logically follow from this one.
>

Holy shit try to post something that makes sense.

Re: Concise refutation of halting problem proofs V52 [ error or dishonesty ]

<RqidnSdLIdwH2GX8nZ2dnUU7-SXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 31 Jan 2022 14:24:57 -0600
Date: Mon, 31 Jan 2022 14:24:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.1
Subject: Re: Concise refutation of halting problem proofs V52 [ error or
dishonesty ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
<2ZqdnX-fD72xnWn8nZ2dnUU7-LHNnZ2d@giganews.com>
<Ol0JJ.27499$541.4855@fx35.iad> <875yq2h2ea.fsf@bsb.me.uk>
<st62tu$f6h$1@dont-email.me> <LCwJJ.50318$gX.12924@fx40.iad>
<UK-dnQx29oAWMmv8nZ2dnUU7-WvNnZ2d@giganews.com> <_bzJJ.7760$rU.4222@fx34.iad>
<gv2dneHXF-XaWGv8nZ2dnUU7-KfNnZ2d@giganews.com>
<d5AJJ.57716$4C3.3626@fx13.iad>
<g6WdndvEcI0PeWv8nZ2dnUU7-VPNnZ2d@giganews.com>
<gVBJJ.317834$qz4.289863@fx97.iad>
<a6adneLIPaTubWv8nZ2dnUU7-anNnZ2d@giganews.com>
<mWCJJ.57596$zV.23696@fx43.iad>
<ZrSdnQfr6bvYnGr8nZ2dnUU7-UvNnZ2d@giganews.com>
<osEJJ.11004$uP.10312@fx16.iad>
<9P6dnTtqj-DZhmr8nZ2dnUU7-VnNnZ2d@giganews.com>
<ecFJJ.19021$mS1.7877@fx10.iad>
<sMCdnTPlr-FDvWr8nZ2dnUU7-KXNnZ2d@giganews.com>
<7FFJJ.29151$541.18496@fx35.iad> <st7a2e$oo$1@dont-email.me>
<ibHJJ.56320$u41.55552@fx41.iad>
<hK-dnaKCNvKd2Wr8nZ2dnUU7-fPNnZ2d@giganews.com>
<gIHJJ.29153$541.4042@fx35.iad> <st91ek$p4g$1@dont-email.me>
<st9fn6$60s$2@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <st9fn6$60s$2@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <RqidnSdLIdwH2GX8nZ2dnUU7-SXNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-HaHOMyCjNh2zX57obXAVTBWYciZeJFTIn4rzccnCyrMZhKk3lPgMuD1hZHTU9U5de9hv/69cr5P7sj1!tdjzHnoWRIqxIyfRTJKCoMcWXljem4A7iJK3Q3NjW6o3WJ74p7Rsy+C/SccUWenzsa0DDiShavo8
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4312
 by: olcott - Mon, 31 Jan 2022 20:24 UTC

On 1/31/2022 2:10 PM, Ben wrote:
> On 1/31/2022 8:06 AM, olcott wrote:
>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>> On 1/30/22 9:05 PM, olcott wrote:
>>
>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn
>>>>> iff H goes to that corresponding state.
>>>>>
>>>>
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>>>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>>>
>>> Right, and the
>>>
>>>>
>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in
>>>> the same way that (1,2) is NOT syntactically specified as an input
>>>> to Sum(5,3)
>>>
>>>
>>> Right, but perhaps you don't understand that from you above statement
>>> the right answer is based on if UTM(<H^>,<H^>) Halts which by the
>>> definition of a UTM means if H^ applied to <H^> Halts.
>>>
>>
>> The biggest reason for your huge mistakes is that you cannot stay
>> sharply focused on a single point. It is as if you either have
>> attention deficit disorder ADD or are addicted to methamphetamine.
>>
>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>
>> After we have mutual agreement on this point we will move on to the
>> points that logically follow from this one.
>>
>
> Holy shit try to post something that makes sense.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Richard does not accept that the input to the copy of Linz H embedded at
Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.

--
Copyright 2021 Pete Olcott

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

Pages:123456789101112
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor